Skills are all you need

The last note asked what happens when every digital experience converges to a chat, a memory and a view. This one goes a layer down: what if the architecture underneath converges too, to nothing but context and skills?

Imagine this. The first agent the user talks to is a pure orchestrator. It has context on its role and a set of skills available to it: start_agent, read_document, process_spreadsheet, discover_agent_skills. It understands the task given to it, starts agents with a defined scope, and hands each one the skills it needs. It doesn't do. It just orchestrates.

Each sub-agent is built the same way: a context and a limited set of skills, both shaped by the agent that started it. And because a parent can shape a child into an orchestrator too, the pattern nests as deep as the task demands.

The build for any product collapses to two things: context and skills.

So the build for any product collapses to two things: context and skills. Then layers upon layers of agents. Dead simple, and brilliantly elegant.

Why skills? Because the whole game with models is managing their context, and skills are the neatest way to do it: each one discovered progressively, loaded only when needed, everything organised. With a few clever design choices they stretch further still: skills can replace connectors to external services and hold the API integrations, create the views, provision the databases and the compute.

We tested it on ourselves. We took one of our products, a system that processes CPG operational documents, and rebuilt it on this architecture. Speed went up 3x and the pre-defined architecture shrank to a fraction of itself, because the model now decides for itself what each situation needs. The finding, plainly: the less we restricted the model, the better it worked, and the less purpose-built scaffolding each new use case required.

Not everything is solved. The hard problems now sit between the layers:

• ▪An orchestrator that shapes a sub-agent's context badly poisons everything below it.
• ▪Errors compound quietly down the tree.
• ▪Handing skills down the stack is handing down privileges: a security question still open.
• ▪Debugging a deep stack of agents remains miserable.

Those are the problems worth working on.

If the last note argued the build stops being the expensive part, this is one way it happens.