Almost nobody is building the shared components for AI, and that is the gap. The industry is pouring effort into orchestration, the conductors that wire agents and tools together, while the things being wired remain bespoke, rebuilt from scratch in every project. The missing layer is a bank of reusable, trustworthy AI components with their guarantees baked in: retrieval, memory, audit logging, evaluation, a deterministic shell. Build that layer and AI gets cheaper, faster and more aligned by default. It is also the precondition for apps that assemble on demand and are thrown away after.
Ross Jones, Founder, The Hopium Lab. Last modified 22 July 2026.
A market observation from someone who builds developer tools and keeps rebuilding the same primitives.
What is everyone actually building?
Everyone is building orchestration, the layer that coordinates agents, routes between tools and manages the control flow of a multi-step task. Every month brings another framework for wiring agents together, and they are largely variations on the same conductor: here is how you define an agent, here is how you chain them, here is how you pass state.
Orchestration is a real problem and some of these are good. But the field has a glut of conductors and a shortage of instruments. The frameworks assume the components they coordinate already exist and are trustworthy, and mostly they do not, so every team wires their orchestration to a retrieval layer they built themselves, an eval harness they built themselves, an audit trail they built themselves, each one slightly wrong in a way they will discover in production.
The AI industry has ten ways to conduct an orchestra and almost no shared instruments. Everyone is writing the score. Nobody is making the violins.
What is the component layer that is missing?
The missing layer is a set of reusable AI primitives that carry their own guarantees, so you compose from tested parts instead of rebuilding the risky bits every time. Not a framework to wire things together, the things being wired. A retrieval component that handles chunking and ranking correctly. A memory component with real persistence and forgetting. An audit-log component that is tamper-evident by construction. An evaluation harness. An idempotent tool-call wrapper. A deterministic shell that validates model output before anything acts on it.
The defining property of a real component, versus a snippet you copy, is that the guarantee lives inside it. The idempotency is in the tool wrapper, not re-implemented per app. The tamper-evidence is in the audit component, not reinvented and got subtly wrong. The safety is a property of the part, so anything built from the part inherits it. That is what makes a component bank more than a code-sharing convenience, it is how correctness stops being re-litigated in every project by whoever happened to build that piece.
Why does this make AI cheaper, faster and more aligned?
Because a component you compose is a component you do not rebuild, debug or get wrong again. Cheaper is the obvious axis: the hundredth team to need retrieval should not pay to build retrieval, and a shared component amortises that cost across everyone who uses it. Faster follows: you assemble an application from vetted parts in an afternoon instead of building and hardening each part over weeks.
Aligned is the axis people miss and it is the most important. When the safety property is inside the component, every application built from it is safe on that axis for free, and, crucially, cannot easily be built unsafe. An audit component that is tamper-evident by construction means every app using it has a tamper-evident log whether or not its author understood why that mattered. Alignment stops depending on each developer re-deriving the right thing under deadline, which is exactly when the right thing gets skipped. The guarantee is structural, not aspirational, which is the only kind that survives.
What does this unlock?
It unlocks ephemeral apps, software assembled on demand for one task and discarded after, because you cannot safely assemble on demand from parts you do not trust. The trend is already named by people who ship: Vercel's chief executive describes the future of apps as "generated on demand rather than downloaded and installed", and industry forecasts for 2026 put short-lived, purpose-built AI-generated applications front and centre, a user requesting a temporary module rather than opening a dedicated app.
The blocker is trust. An app spun up in seconds and thrown away after is only viable if the parts it is assembled from carry guarantees the ephemeral app inherits automatically, because nobody is going to security-review an application that exists for four minutes. If the retrieval, the audit trail and the deterministic shell are trustworthy components, the ephemeral app built from them is trustworthy by inheritance. If they are bespoke and unreviewed, the ephemeral app is a Frankenstein nobody can govern, which is the exact failure the same forecasts warn about: patchwork systems that become token money-pits and cannot be governed. The component bank is what separates "apps that assemble themselves safely" from "an ungovernable sprawl of disposable liabilities".
| Layer | State of the art | What is missing |
|---|---|---|
| Orchestration | Crowded, a new framework monthly | Nothing; this is over-served |
| Components | Rebuilt bespoke per project | A shared, trustworthy bank with guarantees inside |
| Discovery | Ad hoc | A way for agents to find and compose components, a skill base |
| Ephemeral assembly | Emerging (generated UIs, disposable apps) | The trusted parts to assemble safely from |
| Governance | The named 2026 problem | Guarantees that live in the components, inherited upward |
What are the failure modes?
Four, each a way the layer gets built wrong or not at all.
Building the eleventh conductor. Adding another orchestration framework to a saturated field because it is the visible, fundable-looking problem, while the component layer stays empty.
Components that are not actually reusable. Publishing "components" so coupled to their original context that using them elsewhere is harder than starting over. A component that only works in the app it was extracted from is a snippet with ambitions.
Guarantees on the outside. Building components where the safety is documentation, "remember to validate the output", rather than structure. Anything you have to remember to do gets skipped, and the component provides no protection it did not enforce.
Ephemeral without governance. Racing to disposable apps before the trustworthy parts exist, producing exactly the ungovernable, cost-exploding Frankenstein sprawl the trend's own forecasters warn about.
How would you build it?
Build components whose guarantees are structural, discoverable, and genuinely decoupled, and treat the guarantee as the product.
WHAT MAKES A REAL AI COMPONENT
The Hopium Lab · v1.0 · 22 July 2026 · take it, fork it, argue with it
THE GUARANTEE IS INSIDE
[ ] The safety property is enforced by the component, not documented
[ ] An app built from it cannot easily be built unsafe on that axis
[ ] "Remember to..." is not a guarantee; a type or a check is
IT IS ACTUALLY DECOUPLED
[ ] Works outside the app it was extracted from, with clear inputs/outputs
[ ] No hidden dependency on its original context
[ ] Using it elsewhere is easier than rebuilding it, test that claim
IT IS DISCOVERABLE
[ ] An agent can find it, read what it does, and compose it
[ ] The description is written for a model, not a human reading docs
[ ] MCP or an equivalent makes it reachable, not just importable
IT COMPOSES SAFELY
[ ] Two components combined do not void each other's guarantees
[ ] The ephemeral app assembled from them inherits their safety
THE TEST: could an agent assemble a throwaway app from your components,
and would that app be safe without anyone reviewing it? If yes, you have
built the layer. If no, you have built snippets, and the ephemeral future
runs on snippets at everyone's peril.
The gold rush is orchestration because orchestration looks like the product. The durable value is in the components underneath, because that is where cost, speed and alignment are actually decided, and it is the foundation the on-demand, disposable-app future has to stand on. Someone will build that layer. It is less glamorous than a conductor and it is worth far more.
Ross Jones, Founder, The Hopium Lab. Last modified 22 July 2026.