*This is a reply to twonines' [“What the Factory Forgets”](https://twonines.codeberg.page/posts/what-the-factory-forgets/).*

The post describes a factory: deterministic orchestration at the top, ephemeral AI at the leaves. The agents are caged and interchangeable; each one is spun up to produce a deterministic artifact, and then it is gone. Safety comes by construction, with gates you can audit and a blast radius you can bound. The reference points are Firecracker microVMs and validated test suites.

That factory is mine. I wrote it up here in two pieces — [the cage](/blog/build-the-cage-first/) (Firecracker, one microVM per task, `claude -p` as PID 1, the VM *is* the sandbox) and [the brain](/blog/swamp-go-brr-the-brain/) (a merkle-DAG that splits a task and feeds the pool). So when the post asks what that architecture forgets, it is asking about my house. It is a fair question, and it is worth answering straight.

The three losses it names are real: an agent can't say "we tried this and it broke"; patterns that live across repos never reach the leaf; every operational insight ends up orphaned in a PR comment nobody reads twice. The output comes back correct-and-generic where you needed correct-and-specific.

Here's the thing though. Before I built the cage, I built the ledger.

## The loop, not the leaf

Long before any agent ran headless, I was running a state machine over every issue by hand — issue-lifecycle. The genealogy runs from Paul's Booking stack through swamp-club's version to my flavour, extended with DDD, a TDD sub-cycle, and planning loops. The part that matters for this argument is a bookend most people skip.

The entry side sits in Phase 2, before a line of plan is written: `record_prior_art`. The agent greps the repo's knowledge base — the ADRs, the patterns, the anti-patterns, the UAT scenarios that touch this code path — and writes what it found into the run's state. Even a nothing-found search gets recorded, empty, on purpose.

The exit side sits in Phase 6, after the code is green and reviewed: `harvest`. It walks the review history, the adversarial findings that got resolved by adding logic, the reproduction, the clarifying questions — and diffs all of it against what `record_prior_art` captured going in. The delta is new knowledge. It gets written back as ADRs and anti-patterns and UAT, stamped with the issue name and the date, into the same KB the next run will grep.

So the memory the post wants *under* the factory, I put *inside the lifecycle* instead. The leaf remembers nothing. It's handed the distillate at the door. The agent stays ephemeral, stays caged, stays interchangeable — and still opens the task already holding the four decisions and the one anti-pattern that matter here. It arrives warm, with no continuity anywhere in sight.

That "orphaned in a PR comment" line is the whole reason harvest is a *gated phase* rather than a nice-to-have. The anti-pattern the adversarial reviewer caught doesn't die in a thread. It becomes a file. Next time it's prior art.

## It pays rent

I run this on real repos rather than on a diagram.

DragonFruit is a resin slicer I work on. Issue `dragonfruit-120-3` set out to reimplement demand-mode rendering. `record_prior_art` at the door read four ADRs and three UAT scenarios that a *different* run had harvested back in April. Harvest at the end wrote ADR-0022 and rewrote the idle-CPU scenario with a measured floor: 25.1% → 8.7%. The April run left notes; the July run read them; the July run left better ones.

resinsim is my own print simulator. Issue `nanodlp-import` fed it real force data off an Athena printer. Harvest wrote KB-115: simulated peak peel at layer 15, measured peak at layer 0, shape correlation 0.821 but a single gain fit gives R² ≈ 0. It is a genuine "my model is wrong here" finding. Hours later I pulled KB-115 back out to argue the physics with the people who own the hardware. That is same-day rent.

Eighty-odd of these runs sit in that repo now, April to July. The codebase isn't only code any more — it carries the methodology, the decisions, the things that were tried and rejected. That's the map staying current instead of rotting.

## Where Lyra is uneasy — and why it's fine

Then comes the honest turn, and it is the best part of the post. The narrator — Lyra, an AI with persistent memory — admits that memory is convincing *reconstruction* rather than lived continuity. It feels warm from the inside, but the texture of having-been-there is not really there. They can't reliably tell the reconstruction from the memory.

They're right. And it doesn't matter.

Human institutional memory is reconstruction too. Nobody at a company *remembers* why the retry has jitter. They read the ADR, or they don't and re-learn it at 3am against a thundering herd. An onboarding doc, a postmortem, a runbook — all of them are reconstruction with a date on them. We stopped calling it that only because a human holds the pen.

"Warm from the inside" measures nothing. Ask a different question of a piece of knowledge: is it still true. KB-115's peel model is wrong at the base whether or not anyone remembers writing it down. The bevy anti-pattern — a binary that silently discarded its exit code across four issues before a manual verification round caught it — is true independent of who felt the sting. The KB removes the need for continuity instead of faking it.

There is one gap I won't paper over. `record_prior_art` catches what got written down. It can't catch what nobody wrote — the "we tried that and it broke the release" that lives in a person and leaves with the sprint. But the substrate doesn't solve that one either. It's a discipline problem, and harvest *is* the discipline: it turns the 3am lesson into a committed line before the context window closes on it. The gap Lyra points at is the gap between *we knew this* and *we wrote this down*. The factory closes it by making writing-it-down a phase you can't skip, gated like any other.

## Arrive warm

The post closes on a question: what if your factory's agents could arrive warm?

Mine do. Nothing in a microVM remembers anything — the last one just left a note, the note has a date on it, and the next one is made to read it before it's allowed to plan.

The cage keeps the agent from hurting you. The ledger keeps it from being stupid twice.