The composable stack showed up in the spring. By summer, one of its layers was already buying its way out.
In the last days of March, OpenAI published a Codex plugin that runs inside Claude Code. Apache-licensed, built to operate as a subagent, shipped into a rival’s environment with no partnership and no announcement. Three days later, Cursor shipped an agent-first workspace: every running agent, local and cloud, across every repo, in one pane.
The coverage called it convergence. That’s not right.
Convergence means the tools are becoming one. What actually happened is each tool settled into a layer. Cursor took orchestration, managing fleets of agents across repos and environments. Claude Code took reasoning-heavy execution. Codex took code generation at scale. The pattern mirrors how infrastructure tooling matured a decade ago: Prometheus for metrics, Grafana for visualization, PagerDuty for alerts. Specialized tools, composable by design.
If you’ve been building this way, using different tools for different functions and resisting the urge to find one that does everything, the market just validated your instincts.
Then in June, Cursor announced it was pre-training a 1.5-trillion-parameter model from scratch. Not a fine-tune of somebody else’s base weights. A full training run, owned end to end. It still routes to Claude and GPT and Gemini; the new layer goes underneath rather than closing the doors. The reason given was dependency: the labs can change pricing, rate limits, and context behavior at any time, and everything downstream absorbs it.
Read that as a business decision and it’s unremarkable. A company reducing supplier risk.
Read it as an architecture decision and it’s the tell. A layer inside the composable stack looked at its own position and concluded that composing into someone else’s stack was not a durable place to stand.
The vendors won’t accept being a pure spoke. Worth asking why you would.
The composable stack solves horizontal composition. Tools talking to tools. Data flowing between them. Specialized layers doing their specific jobs.
What it doesn’t solve is vertical compounding.
Open a session in any of those tools tomorrow morning. It doesn’t know what you built last week. It has no memory of the architectural decision you spent three hours on Tuesday, no record of the vocabulary your team uses for your domain, no understanding of the non-negotiables your most important client put in writing six months ago. The tool didn’t forget. It never knew; there’s no layer in the composable stack designed to accumulate.
The tools compose. The knowledge doesn’t.
This isn’t a flaw in any of the tools. It’s an architectural gap. The composable stack is excellent at routing: data flows in, gets processed, flows out. Routing and accumulating are different functions, and the composable stack was built for the first one.
Consider what happens without the second. Every session, you rebuild context. Re-explain the domain. Re-establish what’s in scope. Re-surface decisions that already got made. You do this not because you forgot. The stack did. The overhead feels manageable at first. Four months in, it’s a tax on every session. Every person on your team is rebuilding context independently, inconsistently, from whatever happens to be in their head that morning.
The tools got faster. The knowledge didn’t accumulate.
What a hub does is structurally different from what a spoke does.
A spoke executes. It’s deterministic, auditable, reliable. It does the same thing every time. That’s the feature. Spokes are where the work happens.
A hub accumulates. It holds what the organization knows: brand voice, business rules, domain vocabulary, architectural decisions, team patterns. The knowledge that takes months to develop and used to live exclusively in a few people’s heads. Active context that shapes every decision the spokes make. It doesn’t need to be found. It’s already there.
The relationship is bidirectional. Spokes route data into the hub: inputs, events, results. Spokes route instructions out: approved actions, formatted outputs, triggered workflows. The hub holds the judgment that decides what the spoke does with what it receives.
Remove the hub, and the spoke still executes. It just executes without judgment.
More spokes don’t solve this. More tools in the stack don’t solve it either. Routing data in more directions doesn’t create a layer that accumulates. Confusing the two is how you end up with excellent infrastructure that doesn’t get smarter over time.
The operators who build a hub compound. The stack gets smarter as the hub grows. New tools plug into a center that already understands the business. Context isn’t rebuilt at the start of every session; it’s updated.
The operators who connect tools without a hub are on a performance treadmill. Better models, faster outputs. But the knowledge ceiling stays where it was. The advantage built with the AI stack is as durable as the last session, which is to say, not durable at all.
This is what “memory as moat” means in practice: compounding return on organizational knowledge that only accrues when there’s a center for it to accumulate in.
The composable stack validates the spokes. The moat is in the hub.
The composable stack event is real, and it matters. Three tools composing without coordination is the market telling you the right architecture is layered and specialized, not monolithic. That part is settled.
What the event didn’t settle: what lives at the center.
Spokes route data in. Spokes route instructions out. The hub is where it compounds.
The market built the first two. The third isn’t in any of the tools that composed this spring, and it wasn’t in the one that spent a pre-training budget trying to build its way to solid ground. That’s not a technical gap. A hub isn’t a tool. It’s a decision about what your organization is going to invest in building, maintaining, and feeding over time.
The operators who answer that question are building something their tools can’t replicate on their own.
The stack is now available to everyone.
The compounding is not.
What’s your current hub? Or are you operating without one? Reply with what you’re using.
The hub solves accumulation. The harder question: does the knowledge you’re accumulating belong to you? Next issue: the AI capital you’re building right now, and who owns it.
Last week on Systems Intelligence
Issue 3: RAG Is Retrieval. Context Engineering Is Architecture. covered the five architectural decisions most teams never make above the retrieval layer. Good context architecture makes an agent reliable inside a session. This issue is about what survives between sessions.
Systems Intelligence covers AI architecture for the Pragmatic Operator: builders who need AI that works, not AI that demos. If this resonated, forward it to someone assembling a stack. If you’re new, start with Issue 1.
— Jerry Shields · systemsintel.dev