Anatomy of an agentic OS: teaching software to ship software

For fifteen years I shipped software the normal way: a conversation becomes a ticket, a ticket becomes a sprint item, a sprint item becomes a pull request, and somewhere between four humans and three handoffs, a week disappears. The interesting question was never “can AI write code?” — by 2024 that was settled. The question was: what does a delivery organization look like if you rebuild it as software?

That’s what we’ve been building at Anatta. Not a coding assistant, not a chatbot bolted onto a project tracker — an operating system where agents run the workflow and humans keep the authority. The internal shorthand is blunt: agents talk, work ships. This essay is about how it actually works under the hood, and what building it taught us.

The harness, not the model

The first engineering decision was the most important one: the intelligence lives in the harness, not in any single model call.

Delivery is a loop with nine stages — intake, sale, onboarding, discovery, solutioning, sprint planning, build, QA, ship. Each stage gets a specialized agent with its own context, tools, and definition of done. No mega-agent trying to do everything; a mega-agent is just a junior employee with amnesia and confidence. Narrow agents with crisp handoffs behave like a team. The stage boundary is the API.

The second decision follows from the first: agents don’t share vibes, they share state. One memory, one audit trail, one command structure. When the discovery agent turns a client call into a PRD, the solutioning agent reads the same record the sprint-planning agent will later decompose and the QA agent will eventually test against. There is no “let me forward you that email.” The context is the system — which means the transcript of a Monday 10:04 call is, by 10:19, a scoped task with description, acceptance criteria, owner, and dates, and every downstream agent can trace its work back to the sentence that caused it.

No approval, no action

Here’s the rule that makes the whole thing deployable in the real world, with real client money on the line:

The layer never freelances. Every consequential step — scope approved, build started, change published — stops at a human gate. Agents arrive at the approval queue with the work done and the reasoning attached; a delivery manager reads the evidence and signs. Publishing is a human act. Always.

From an engineering standpoint this was counterintuitive. We could let the pipeline run end-to-end; the demos were spectacular. But trust, not capability, is the bottleneck of agentic systems. An agent that is 95% right and 100% autonomous is unshippable — the 5% lands in production with nobody’s name on it. Flip the design: agents propose, humans dispose, and every decision is logged and auditable. Suddenly the same 95% agent is a force multiplier instead of a liability, because the failure mode changed from “silent wrong action” to “wrong draft in a review queue.”

The gates also did something we didn’t fully predict: they moved the humans up the stack. When approval is the job, writing sharp acceptance criteria becomes the scarce skill. Our best people stopped doing table-stakes execution and started doing judgment.

One pass through the loop

Concretely, a small change flows like this:

1. Your team mentions a homepage change on a call. The notetaker agent files the conversation — decisions, context, files.
2. Minutes later a scoped task exists: description, acceptance criteria, owner, dates. A delivery manager approves the scope. (Gate one.)
3. An engineering agent builds it against the actual design file.
4. A QA agent tests it — desktop, mobile, tablet — against the criteria from step 2. It finds a spacing bug, files it; another agent fixes it.
5. A preview link and a reviewable change land in the queue, verdicts attached. A human reviews the evidence and signs off. (Gate two.)
6. Live when you say. (Gate three, forever.)

What used to be a week of standups is an afternoon. Multiply it across a quarter and the compression is absurd: a three-month redesign shipping in one, a redesign plus subscription portal in three weeks, twenty-seven landing pages in under a week. The steady state we keep seeing is five agents and one human carrying an account end to end.

What building it taught me

The bottleneck migrates; it never disappears. We removed the coding bottleneck and hit the review bottleneck. Then we made review cheap — evidence attached, diffs small, verdicts pre-run — and hit the specification bottleneck. Agentic systems don’t eliminate work; they distill it toward the parts only judgment can do.

Loud failure is a feature. Early on we optimized agents to recover gracefully. Wrong instinct. A delivery system’s job is to surface reality fast — a QA agent that reports a broken link before the customer sees it is worth more than one that quietly retries. We now design for honest, legible failure at every stage.

Determinism at the edges, freedom in the middle. The workflow — stages, gates, audit trail — is rigid and boring on purpose. Inside a stage, the agent has room to think. Every time we blurred that line in either direction, the system got worse: rigid inside meant dumb agents; loose outside meant chaos with a nice UI.

The OS metaphor is load-bearing. Agents are processes. The shared memory is exactly that. Approval gates are syscalls — the only way user space touches the real world. Once we started treating it as an operating system instead of a collection of bots, the architecture decisions started making themselves.

The economics fall out naturally: when table-stakes execution collapses from half the budget to a rounding error, the freed capital goes to the only thing that compounds — growth. But that’s an essay for the investing side of this site.

We’re still early. The harness gets tighter every week, the agents earn more scope, and the humans keep the pen. That last part isn’t a limitation of the system. It is the system.