The Control Layer, Shown — Part 2: The Manager and the Interns

Part 1 honored Mozilla.ai’s John Dickerson — control is the moat, and you should be able to see it. This part honors the other essay that named what we build. In Agent Developer Workspaces, Monaco’s John Tracy asked a question that lands exactly where we live:

“what if I can work in 1 ‘manager’ agent that spins off dozens of ‘intern’ agents to handle individual tasks?”

He is right, and — like Dickerson with Otari — he did not just write it. He built Monacoder: real cloud workspaces where agents run in parallel, each with its own isolated instance and “test data that (safely) resembles that of a real production application.” Build over buy, because the specific need was worth building for. We made the same call. What follows is how the manager and the interns actually fly here — with one distinction that matters.

The interns fly in parallel — for analysis

The manager’s first job is not to write code. It is to understand the work. StellarView grounds a constellation from the real client registry and the real meeting record: three epics, thirty-nine work units, an estimate in hours — and every unknown surfaced as a gap.

This is where the interns earn their name. One hundred and eleven gaps, resolved by agents working in parallel — because analysis is exactly the place parallelism buys you something real: coverage. Each answer is grounded in the registry and the transcripts, each one cited, and a self-test rejects anything the sources do not support.

Parallel intern agents here do not race to be fast. They race to be thorough — so that nothing enters the build unexamined. Tracy’s interns, pointed at the part of the job where more eyes means more accuracy.

The code is written by one agent — sequentially

Here is the distinction we hold deliberately. When it is time to actually write the software, we do not turn dozens of interns loose on the same repository. The code is written by a single agent, moving sequentially through the resolved plan — one work unit after another, each gated, each verified, branch chained to branch.

We are not trying to conjure an enterprise city inside a chatbot overnight. That is the fantasy the market keeps selling and keeps failing to ship. Correctness is not a thing you parallelize your way into; it is a thing you earn one verified step at a time. Parallel where parallel makes us accurate; sequential where sequential keeps us correct. The manager knows the difference. That is the whole point of having a manager.

Seeded, production-like data — the part everyone skips

Tracy is right that the workspace is worthless without real data in it: “populated with test data that safely resembles that of a real production application.” An agent reasoning against an empty database is guessing.

Our answer is the Space Lake — a grounded, seeded data plane the whole fleet reasons against. The Cicero plan did not come from the model’s imagination; it came from the client’s real registry and real Fathom transcripts, recalled with attributed quotes. Seeded, production-like, safe. The intern that guesses is the intern that ships a bug; the intern that reads the lake ships the requirement.

We have shown the lake in public before. In Karpathy Ingests Karpathy, an outside body of writing was pulled in, tiered bronze → silver → gold, classified into an ontology, indexed with embeddings, and made queryable end to end — you can open the serialized result as a knowledge graph and watch the nodes light up around what the source actually said. Same machinery, pointed at whatever knowledge a build needs.

And here is the point that is easy to miss and impossible to overstate: the lake is cultivated. We built it, grounded it, curated it — once. So we do not pay the model, token by token, run after run, to re-derive and re-model the things we already know. It reads what we cultivated. That is Lake and Control working together: spend tokens discovering what is genuinely new, never re-inferring what is already true. Tracy was right that the workspace is nothing without real, seeded data in it — and he was so right; the corollary he points at is the one that pays the bills: once you have cultivated that data, you never rent it back from the model again.

Push that one step further and it stops being clever and becomes operational discipline. Once knowledge is cultivated, serving it runs almost for free on ordinary hardware — it behaves like any other serverless operation, not like a live model call. Which lets us hold a rule as law: never put a live model on a path that, if it stalled, would stop your business. Anthropic goes down. Providers get overloaded. Rate limits land at the worst possible moment. A company that wired a live LLM call into its critical path just stopped; a company running on a cultivated lake never noticed. And the cultivation itself is a flow that can be — and routinely is — interrupted and resumed, precisely so that the operations depending on its output never inherit the fragility of the thing that produced it. Control is not only knowing what the model did. It is not needing the model to be up.

And this is not optional where humans depend on AI against a clock — a clinician mid-visit, an attorney at a closing, a filing that is due today. When the dependency is time-sensitive, resilience is not a nicety bolted on later; it is the design requirement from the first line. You build the interruptible, cultivated path because a person is waiting and the answer cannot be “the provider is overloaded, try again.”

That is the whole shape of it. The model does its non-deterministic work elsewhere — in a parallel plane, on its own time — exploring, drafting, cultivating. What crosses the boundary into the running process is deterministic “automation intelligence,” fixed and reviewable. The business consumes determinism; the model’s uncertainty stays in the other universe where it belongs, and is invited into the process only as settled, cultivated output. That is the same instinct as a policy gate outside the reasoning loop — pulled all the way up to the level of the business itself.

By the time that output reaches you, the model has already done the work, tested it, and evaluated it against your standards — your evals, not its own confidence — and then delivered the efficiency to the point of use as if by folding time. It is Madeleine L’Engle’s tesseract from A Wrinkle in Time: the fabric pleated so two distant points touch, the long way around collapsed to a step. The exploration and the verification happened elsewhere and earlier; what lands in the moment is the proven, compressed result, as though the distance between the question and the answer had simply been folded away.

This rhythm has a name here — the Pulse — and it runs through everything in the Stellarverse. But be precise about where it pays, because it is not every gap between actions. Plenty of waiting is harmless. The expensive kind is the known thing waiting on a known action — the important email sitting unread in some manual process, the next step everyone agrees needs doing that simply nobody did yet. That is a customer angry for five hours over something that was never uncertain, only unattended.

The old world reclaimed dead time only for exotic, latency-bound cases — a trading desk paying for a shorter cable. The Pulse reclaims it exactly where it quietly bleeds ordinary businesses: the deterministic action a human happened to be the bottleneck on. The answer was already known, out in the parallel plane. The Pulse folds it into the moment before the customer ever has to wait.

So — go fly a kite. That is precisely what Faberi.ai did with the flight deck from Part 1: you launch a kite over the org signal, and when the known thing appears in the wind — the email, the trigger, the action that was only ever waiting on someone’s attention — the kite handles it, deterministically, on the beat. That is what let Shawfield Realty and LandVista / RE-Prise turn five-hour waits on known actions into things that were simply already done. The kite was already up. The answer was already known. The customer never had to wait.

What we actually optimize

This is where we part company with the “faster!” crowd, and it is worth saying plainly. In the agent world, the wall-clock minutes a human waits between outputs cost us nothing. What we spend, measure, and defend is tokens, accuracy, and control — the same three things Dickerson and Tracy keep circling. Cheap where it can be cheap. Exhaustively grounded where it must be right. Governed at every gate. Speed is a byproduct we do not brag about; accuracy and control are the product.

The manager coordinates; the interns analyze in parallel; one agent writes the code straight through; the lake keeps everyone honest. Tracy drew the shape. This is it, flying — with the seams shown.

The Rumsfeld Maneuver

Name the whole move and it snaps into focus. The system captures the known knowns — the deterministic actions that were only ever waiting on someone’s attention, now handled by Kite on the beat. Its parallel interns connect those to the known unknowns — the gaps, the questions we already know to ask, resolved and cited against the lake. And with the first two handled cheaply and out-of-band, capacity is finally freed to help solve the unknown unknowns — the things nobody thought to look for until the cultivated ground made them visible.

Call it the Rumsfeld Maneuver for cloud-based folding of time: sort the world into knowns and unknowns, automate the first, close the second, and spend the reclaimed time hunting in the third — all of it out in the parallel plane, handed back to the business as determinism, on the Pulse.

The point of Part 2

The interns are real, and they are pointed where they belong: at analysis, in parallel, for coverage. The code is written the way correct code gets written — by one agent, sequentially, gated all the way. Not overnight magic. Tokens, accuracy, control.

Next — Part 3: Not One App, a Fleet of Platforms. Everything above produced one running system. But StellarView did not introduce itself with one app — it introduced itself with a Gang of Five vertical platforms, and there are many more in the libraries. We will walk the fleet.

---

References: The Control Layer — Mozilla.ai, John Dickerson · Agent Developer Workspaces — Monaco, John Tracy · Amazon Bedrock AgentCore