The architecture, in two generations.

Generation one: work as files.

The first generation came from a blunt observation: chat sessions die, and files survive. So every piece of work became a markdown file. A task file named its goal, its scope, and its risk level, and the folder it sat in was its status. Moving a file from pending to active to done was the workflow, and git kept the history for free.

An architect model framed the work and wrote the task files. Executor agents claimed them, did the work, and reported back into the same file. A small daemon script, with no model inside it, moved files between folders, recovered stale claims, and flagged drift between what a task promised and what actually changed. Reviews ran when a batch of tasks closed. Everything stayed readable in a text editor, and when a tool crashed, the state of the whole operation was sitting on disk, intact.

It worked at real scale: the bus has carried more than 440 tasks across 83 batches. That number is the argument for it. You can run a serious operation on files and discipline.

Where it cracked.

Four limits showed up as more of the work became agent-run.

Budgets were advisory. A task file could say "keep this small," and an agent could read that and still overrun it, because a sentence in a file has no enforcement behind it.

Memory lived in silos. Each assistant kept its own notes. Two agents could work the same project for a week and hold two different versions of its history.

Permissions were conventions. Which folders an agent could touch was a rule it was told about. Nothing stood between a confused agent and a directory it had no business writing to.

Dashboards did their own math. Every surface derived its own picture from the raw files, so two screens could honestly disagree about what was running and what it had spent.

None of this was misbehavior you could pin on one agent. The rules existed as prose, and prose does not enforce anything.

The new generation: work as governed runs.

The new generation treats an agent doing work the way an operating system treats a process. Before any agent starts, the job gets a run envelope: a work order with hard edges. It names the goal, the directories the agent may write, the tools it gets, how much it may spend in tokens, time, turns, and dollars, and who has to approve the risky parts. The envelope is validated machinery, so work outside those edges is off the table before a model ever sees the job.

Budgets moved from prose to a ledger. When a run spawns a helper, the child reserves its budget from the family's remaining pool before it starts, and the reservation settles when it ends. Unused amounts flow back. It works like household money: nothing gets spent that was not first set aside, so a swarm of parallel agents cannot collectively overshoot what the operation decided it could afford.

Memory became shared infrastructure. Both assistants now read and write one canonical record, 159 entries and growing, with secrets scrubbed and duplicate captures dropped at the door. Ask either harness about a decision from last month and you get the same answer.

Everything emits receipts. Each run appends events to its own ledger: what started, what was approved, what was spent, what changed. When something goes wrong, nobody's recollection settles it. You read the receipts.

Every screen reads one snapshot. A derived, checksummed read model is generated from the ledgers, and every operator surface renders from that same file. The memory dashboard and the control board cannot disagree, because neither one does its own math anymore.

The runtime is held to 309 automated checks, run green on both PowerShell runtimes it has to survive on, every time it changes.

Same job, different guarantees.

What carried over.

Almost everything the first generation believed survived into the second. Work is still described in plain markdown, because intent should stay readable and greppable. The daemon still has no model inside it, because monitoring is a job for a clock. The old task bus still runs underneath, carrying the human-readable layer, while the runtime handles enforcement.

What changed is where the rules live. They used to live in prose and habits. Now the load-bearing ones live in machinery, and prose is just how they get explained.

What it taught me.

Generation one taught me that structure beats memory: an operation written down in files survives any single tool dying. The new generation taught me the limit of that idea. A rule an agent can technically break will eventually get broken, on a long enough timeline, by an agent confused enough. So every rule that matters got moved from documentation into enforcement.

The agents are the same agents. What changed is how little the system now has to take on faith.