People keep asking me what the AI system of the future looks like, so I drew the whole thing out. It is a reference architecture I call The Compounding Stack, and the interactive version, every layer tappable, lives on that page. This is the story of why it is shaped the way it is.
Ross Jones, Founder, The Hopium Lab. Last modified 4 August 2026.
The thing almost nobody designs for
Here is the property I care about most, and the one I almost never see anyone build toward: the system should get cheaper the more it runs.
Think about how strange it is that this is unusual. Almost every AI system on the market today does the opposite. Every meaningful step calls out to a metered frontier model, so the more useful the system becomes, the more it costs to run. Success and expense are the same number. Teams end up rationing the thing they built to be helpful, because scale is spelled b-i-l-l.
That is a design choice, not a law of nature. You can build the other thing. But to do it, you have to stop treating the model as the system and start treating it as one small part inside an architecture that does the actual work.
Read it from the bottom up
The stack is seven layers, and the order matters, because it is the order the system is built in.
At the base is governed data, our data layer is Integri.us. Everything reasons over this, and it is the single most important decision in the whole design, because it is what lets everything above it be small. On top of the data sits a lightweight local model that turns a request into a structured query. Not a guess, a query, over exact and governed context. This is why the model can be small: a bigger model will not close a gap that is really a data gap, and once the data is right, a local model covers a surprising amount of production.
Above the model is a shared component bank, reusable code where each piece carries its own guarantee inside it rather than in a comment above it. Then a skill base the agents can discover and compose, because everything we build speaks MCP. Then orchestration, agents running defined processes, effectively a loop, assembled from those components. Then execution through FLOW, which is the system of record: every run tracked, replayable, auditable. And at the very top, a render layer where a local model generates the interface a task needs and throws it away after. The UI is ephemeral, because every layer beneath it is solid enough that a throwaway surface can safely inherit their guarantees.
The two loops are the whole point
If you take one thing from the diagram, take the two orange arcs.
Every execution feeds two things back. The code that ran returns to the component bank, so the next loop that needs something like it assembles from parts that already exist. And the results return to the data layer, so the next run starts warm instead of cold. Those two arcs are why the system compounds. A process you have run something like before is smaller this time, and smaller again next time, because more of it already exists.
This is the answer to the loudest argument in AI right now, that self-correcting agent loops are the future. They are, but only when the loop is bounded and shrinks with reuse. An open-ended loop with unlimited tokens and no memory of what it already built is not intelligence, it is an expensive way to redo work. The difference between a loop that compounds and a loop that grinds is whether execution feeds anything back.
Token-optimised, in this architecture, is not a setting you switch on. It is a consequence of reuse. That is the sentence I would tattoo on the whole industry if it would sit still.
Reliable because the guarantee is in the code
The other half of the design is reliability, and it comes from the same place the savings do.
A probabilistic model sits at the front, embracing the mess of human language. A deterministic shell sits behind it, enforcing everything that has to be correct. The safety lives inside the components as behaviour the code enforces, not as an instruction you wrote in English and hoped would hold. That is the difference between a system you can stand behind and one that breaks quietly the next time a model updates.
Small model, strong architecture, guarantees in the components, feedback on every run. Fully local, reliable, and cheaper the more it works.
The full interactive architecture, with every layer opened up, is The Compounding Stack. Go tap the layers.
Ross Jones, Founder, The Hopium Lab.