We built a working agent universe and halted it anyway — because it was built for the wrong kind of growth. What that miss taught us about scale, control and entropy, and the kernel we built in its place.
Here's a sentence I wrote to myself the day we stopped: the experience had become the exhibit of the architecture, when the architecture should have been the servant of the experience.
We had a working universe. Agents with permanent identities. A signed memory. A living console you could fly through. Seventy-three design dives, each one adding something clever. And one Monday in September I halted all of it — no new features, no new rooms — because the instruments were telling me something the demos weren't: it was architected to get slower as it got more complex. One user, one world, and a room that took seventeen seconds to paint at the tail. Dialogs that never loaded because the loops behind them were deadlocking each other. And we hadn't automated anything yet.
It didn't fail. It worked. It was built under the wrong growth context — and I think most agent platforms being built right now are making the same two mistakes we made, so let me name them plainly.
Mistake one: we chased the interface. Every good AI idea got a room in the console. We were fitting the world into the screen instead of asking what the kernel underneath had to become to carry the world. The interface is where you feel governance; it is not where governance lives. When the surface is the product, the substrate never gets the attention that scale demands — and scale always arrives before you're ready.
Mistake two: we made everything a small agent. Every capability was its own little agent, and every agent brought its own identity story, its own memory, its own way of calling a tool, its own idea of what it may do and what it costs. That's fine at five. It's a problem at fifty, and it's a wall at five hundred — because the governance of all those small minds becomes the load. The more complex the intention you hand the system, the more machinery it needs to keep those agents inside their rules, and that machinery was being rebuilt, per agent, per request. The intention got heavier and the architecture got heavier faster.
The name for what we were fighting is entropy. Put twenty agents on one problem and nobody can say who did what, under which law, for how much, or how to stop it. Frameworks add loops; they do not remove the entropy. An operating system removed exactly this kind of entropy for programs decades ago — it took the rigid parts away from every program (processes, files, permissions, the clock) and held them in one place under one law. Nobody writes their own scheduler anymore. That is what a kernel is for, and agents need one.
So we stopped, and we built one.
What we learned, in four lines. Intent drives action — so intention, not the prompt, is the unit a human should control. To control intention you apply control — and the more points of control the kernel holds, the less entropy the fleet can generate. Reproducibility is a kernel job, not an agent job — an agent can't prove its own history; the thing beneath it can. And the human must always be able to stop what the machine manages — every lever the machine has, the person has first.
What the kernel holds. The new Orreth is a small, fast kernel (written in Rust, with a Python reference that pins every law as a test both must pass) that holds the rigid things so the agents don't have to:
- Identity. A keypair is a self, and a self survives the process. An agent that dies comes back as the same self; every act carries its signature. A person sits with a seat the kernel minted after a proof. Nothing acts anonymously, ever.
- Memory. One signed, append-only record. Corrections are siblings, never overwrites. A purge is a governed act that leaves a hash, never the words. This is the infinite-horizon memory the earlier articles describe — agents that never lose their place, at a thinking cost that stays flat.
- Rails. Every ask, reply, fact and tool call rides one envelope over the same rails — a database, a message queue, an event log. Poison is parked with its evidence. Nothing is lost, and everything is replayable.
- The meter. Every thought every agent has goes through one gateway under the agent's own key and lands in dollars. Nothing thinks off-meter. Cost is not a report you run later; it's a fact on the same record as the work.
- The gate. An agent joins through a desk with five states. A person's word is the only thing that admits it. Scopes only narrow. Refusal wears one face, so a probe learns nothing.
- Watches and levers. The kernel watches its own doors, benches, leases and queues. Every remedy is a lever a person can see; a routine one the kernel pulls itself and says so; a consequential one holds until a person says yes.
Because the control is rigid, the experience gets to be fluid. That's the inversion the first architecture had backwards.
Agents live forever, and they have jobs. The kernel seats two kinds of residents. Agent residents are the personas you talk to. Firmware residents are bodies with a function and no persona — the planner, the critic, the grader, the toolkeeper, the stable-keeper who manages the models themselves, and MITL, the mind-in-the-loop that has read the architecture and can tell you what it means. They work three channels at once: they serve you in the chat; they serve the kernel — its policies, schedules and requests; and they do their jobs, by role, on a clock. And every one of them was engineered, seated and scoped by a human, through the kernel. There is no agent in this world that a person didn't admit.
One place to stand, whatever your depth. A simple user, an engineer, an analyst and an architect meet the same two surfaces. A live single pane — the panel — draws the whole world at once: geometry is what is declared, light is what is happening, colour is who did it. And a chat that is not an ordinary prompt: you create standing intentions from it, open and manage any sub-panel from it, summon MITL when you're in trouble, and call an agent in another world by name and talk to it across a signed seam. Everything can be done in chat; the panels are for the eyes.
A built example, because the brief says "show, don't tell." In my running kernel I typed one sentence: keep this world resilient — when a watch goes red, get it green. That's it. I wrote no tool. I asked no specific agent. From that sentence the kernel now holds a standing intention: when any watch turns red — a body stops renewing its lease, a queue backs up, a door gets slow — the kernel opens a forensic dossier of what it can see on the ground, a firmware planner reads it and names a lever from a catalogue, the kernel pulls the lever itself when the lever is routine, and holds for my yes when it is consequential. The outcome — cured, self-healed, still red, cancelled — lands on the record with the name of whoever decided. Every agent, resident and firmware, applies a response to an undesired state I defined in plain words. If the world doesn't have the capability an intention needs, the design is that it learns it, builds it, and uses it — under the same human gates. Having a mind-in-the-loop with read access to the repository, and an architect it can call, is what makes that more than a slogan.
The question I'd put to every Chief. How are you managing your harnesses, your minds, your improvements? Not your prompts — your fleet. The same reproducibility that's easy for one agent becomes a scale problem the day you deploy hundreds: which model version answered, under which policy, taught by whom, at what cost, and can you prove it? In this kernel a model is an identity too — a stall with a pinned deal, a health that's checked, a spend that's watched, an end-of-life that's planned. Its very existence is a storyline the kernel can read back, and improve from. Learning rides the same rails: an offline harness that catches a provider silently changing behavior under you; near-live graded experience folded back into an agent's working knowledge, signed; and — by design, the fourth loop — the scheduled observations of a fleet that never sleeps becoming machine-learning datasets of live state. Everything learned is visible, revocable, and never silent.
What it changes at the top of the org. For the CISO: every actor an identity, every act signed, every learning channel an enumerated surface — never trust, always verify, built into the substrate rather than bolted onto the agents. For the CRO and compliance: an operating state that can answer every question about an event at the time of the event — or before it — with receipts, not reconstruction. For the CIO and CTO: one kernel governing whatever agents you install, extending into your own LangGraph architectures instead of replacing them; a second world is one command away, sealed from the first. For the CFO: cost in dollars on the same record as the work, per agent, per intention — with the design carrying that ledger across agents, architecture and every cloud you run on, because your architect should be able to govern any provider. For the CEO: when the regulator or the enterprise customer asks how you control an army of agents that changes itself, you hand them the record.
And the part that matters most: control. Imagine ten thousand agents running and an event that requires you to touch every one — or to stop them all. A fleet without a kernel has no such lever; it has ten thousand conversations. A fleet on a kernel has a queue every agent already listens to. The lever exists before you need it. That is the whole point of the design: a person can always stop what the machine manages, and the machine ships with its stop.
Think of Orreth as a mill: a machine capable of making itself, with human control, through the use of its own rails. Its scope and its ontologies give it an operating state — an awareness across the whole kernel that agentic automation can act on and humans can read. Any applied schedule becomes a usable dataset of live state. You can imagine what comes next.
We admitted the miss because we're building a deep architecture to sustain massive agentic worlds, and the honest lesson is the useful one: when agents are everything, something must govern — and it must enable humans to govern that. That's what we halted for. That's what we built. Everything becomes an agent; the kernel is what makes that survivable.
Orreth is an agentic architecture governance kernel — an intention-adaptive Rust kernel filled with agent identities — built in the open. I'm exploring senior strategy and architecture roles in agentic infrastructure — say hello.
Next in the series: The Third Loop.