My Stack of Terminals, Documented.

People keep asking about the numbers, the 830-agent sessions, the solo portfolio, and the honest answer is that the numbers come from a setup, not a trick. So here it is, documented: the stack of terminals I actually run, layer by layer, with the operating rules that keep one person in command of all of it.

None of it is exotic. All of it is written down, and the writing down is the setup.

What is the shape of the whole thing?

Eight layers. The terminals are just the visible one.

A constitution per repo. An always-on machine running parallel Claude Code terminals. A 12-seat agent org with charters. Orchestrated fan-outs for parallel work. A pre-commit gauntlet. Mechanical guards. Scheduled jobs. A ledger. Each layer exists because a specific failure taught me it had to, which is why I can explain every piece in one sentence and why the bottleneck was never the code.

What does the constitution do?

It makes every lesson permanent. Each repository carries a CLAUDE.md: the conventions, the protected files no agent touches unprompted, the known anti-patterns with the lesson attached, the commands that matter. Distilled rules, never session stories.

The one discipline that makes it work: it is a living document, updated in the same session a rule is learned. An agent reads the constitution before every piece of work, which means a rule written today governs every agent tomorrow. That single property, perfect institutional memory, is the biggest structural advantage agents have over any team I ever managed.

A lesson in a person's head compounds for one career. A lesson in the constitution compounds for every agent, forever.

How do the terminals and seats divide the work?

By lane, in writing, so nothing contends.

Each terminal owns one concern at a time: a feature on Orbyt, an audit, a content pipeline. The machine is an always-on Mac Studio, so long-horizon work runs around the clock and months-long tasks survive the night. Above the raw terminals sits the org: a 12-seat agent org where every seat holds a written charter, authority splits into 29 autonomous lanes and 40 gated ones, and none of 12 seats can merge to the branch that deploys. The seats are a machine of their own, with 23 scheduled jobs across a 12-seat agent org handling the recurring work while I sleep.

The parallelism people imagine happens in the terminals mostly happens in orchestrated fan-outs instead. My largest single workflow accumulated 298 agents, holding to eight in parallel. One working session spawned 830 agents across seven days, never more than nine live at the same instant. One month of transcripts: 2,800 runs, 2,589 inside 95 workflows, 211 spawned directly. The anatomy of that session is its own post.

What stands between agent output and production?

The gauntlet, then the guards, and nothing has a bypass flag.

Every commit passes typecheck, the unit suite, and end-to-end tests, locally, before it lands. Behind that sit 103 mechanical guards and an audit harness of 84 numbered dimensions, 35 of them blocking at grade A. When something breaks anyway, the incident joins a corpus of 80 recorded incidents, and 56 of them are mechanized into permanent checks, so the same failure cannot ship twice.

The ledger keeps the score honestly: a decision log at 40 entries, and across the last 51 recorded seat runs, 43 completions and 30 discards at gates, an 84.3 percent completion rate. That discard rate is not friction I tolerate. It is the permission model doing exactly what it was built to do.

What are the operating rules at the keyboard?

Four, learned expensively.

One concern per terminal. Two sessions editing the same files is a merge conflict with extra steps. Lanes first, then speed.

Batch everything independent. Agents that fire tool calls one at a time burn context re-reads; the loop is priced by what it re-reads, not what it writes. The same rule governs me: I queue work in batches and review in batches.

Quarantine heavy reads. Images, giant files, and exploratory searches go to subagents that return a summary, so the main context stays lean for judgment. The context economy deserves its own post, and it has one.

Feed the constitution. Every correction I make twice becomes a written rule, every rule becomes agent behavior, and the setup gets better while I do something else. That loop, not any terminal, is the actual setup, because the loop is the unit of engineering now.

What should you copy first?

Not the fan-out. The constitution and the gauntlet.

Write one CLAUDE.md for your main repo this week: conventions, protected files, the three mistakes your team keeps re-making. Then wire the gauntlet so nothing merges without your tests passing, agents included. Those two layers, one afternoon each, are 80% of the value at 5% of the ceremony.

Scale the terminals only after the boring layers hold. A fleet without a constitution is noise with API keys, and I have written about what that becomes.

The setup is not the terminals. It is the written rules the terminals answer to. Document those, and the stack builds itself.

Related reading:

• 830 Agents. One Session. the setup at full stretch
• The Machine. It Runs the Company. the seats and charters in depth
• 84 Ways to Tell Me I'm Wrong. the harness behind the gauntlet
• Loop Engineering: How Orbyt Builds Itself the discipline the whole setup serves