The network
Three layers: agents that operate production systems, agents that build them, and the skills both draw on.
Key services are documented well enough that an agent can rebuild them from scratch. The documentation is the system of record, which is what keeps it honest and current.
The runtime layer is deployed services holding their own memory and telemetry, invoked by external events and operated through the tools a team already has open. The building layer lives in the engineering environment and designs, scaffolds and reviews software — several of its members exist to build runtime agents, which is what makes the network self-expanding. Skills are the packaged know-how both layers draw on.
The registry is the index across all three.
How it works
A building agent encodes how a reliable service is constructed, so the next runtime agent is assembled from patterns that already worked rather than designed from nothing, and the cost of the next one keeps falling.
Each layer is specified to the level a rebuild needs: a service that cannot be rebuilt from its own specification is one whose specification is not exercised, and a gap in it shows up as a rebuild that does not work.
Three layers
| Layer | What it is |
|---|---|
| Runtime agents | Long-running deployed services that operate on production systems. They hold their own memory and telemetry, are invoked by external events, and are used through the tools an operations team already has open — no engineering involvement to run one. |
| Building agents | Specialists that live in the engineering environment and help design, scaffold, and review software. Several exist specifically to build new runtime agents, which is what makes the network self-expanding. |
| Skills | Packaged, versioned know-how — how to integrate a partner, how to model data, how to test a design — that any agent or engineer picks up. Knowledge is written once and reused everywhere, so it compounds instead of evaporating when a person leaves or a system changes. |
The loop
- A need surfaces in plain language.
- The router sends it to the right building agents, which pull in the relevant skills.
- Those agents assemble a new runtime agent from proven patterns.
- The runtime agent is deployed, used through the tools the team already has open, and registered.
- Whatever was learned is captured as a skill, making the next agent cheaper to build.
What holds it together
- Agents that build agents
- Building agents encode how a reliable service gets constructed, so each new runtime agent is assembled from proven patterns rather than designed from nothing. The cost of adding the next agent keeps falling.
- Evidence before action
- An agent that touches production behaviour shows its work first — before-and-after comparisons, dry runs, and human approval gates — so people stay in control of every consequential decision.
- Operations through conversation
- Business users launch pipelines, change rules, request exports, and manage copy by writing plain-language requests, work that previously required an engineer running scripts.
- Consistency at scale
- Because specialists share the same skills and standards, services built years apart still look and behave like siblings — easier to operate, audit, and hand over.