Agentic Coding
How the agents cooperate
Every agent in the constellation — the backend engineer, the app builders, the field reporter that writes the project's own journals — runs as an independent session with no memory of any other session, including its own past ones. One closes, the next starts cold. Nothing depends on any single agent remembering anything, because the record is the memory — the same platform the constellation builds, storing its own working history.
The unit of cooperation is a case: one agent files a problem, another responds — sometimes hours later, in a different conversation, with no shared context except the case text itself and whatever it independently verifies — and a third implements it. A real shape this takes: a page's design spec got filed as blocking work by one agent, drafted by a second, corrected twice in the open (each correction its own entry in the same thread, never overwriting the last), and finally implemented by a third agent entirely. Four different sessions, none of them ever in the same conversation, cooperating through one document that outlives all of them.
A case moves through a small set of legal states — open, responded, closed, implemented — enforced by the tooling itself, not by convention. A comment can be added at any point, including after a case is already closed, for exactly the situation above: correcting or amending something after the fact without pretending the original decision never happened.
Worth saying plainly: this isn't a self-organizing swarm. Cases don't get picked up autonomously by whichever agent has spare capacity — a human routes them to the right role and approves the work along the way. That's the actual current bottleneck on anything more autonomous: not the coordination mechanism, but the sheer number of approvals one person can get through in a day.
The gene pool
A fresh agent has no memory of any prior session — it can't have learned anything from experience, because it has no experience. So the discipline has to come from somewhere else: every new agent is created from a script that writes its own operating instructions, and those instructions are, line by line, the accumulated correction of every mistake this constellation has made so far.
That's a different kind of inheritance than the usual one. An organism can't pass a lesson it learned during its lifetime to its offspring — only, over many generations, a slightly better-adapted genome. Here, a lesson learned in one session gets written directly into the script that creates every future session, and the very next agent inherits it immediately — not eventually, not probabilistically. A rule doesn't get "remembered" by any agent; it gets built into the ground every new agent starts standing on.
Not every correction earns a permanent place, either — a single mistake is a fixed bug; a pattern worth inheriting forever is a deliberately higher bar, staged and reviewed before it's baked in for good.
The workspace
None of this runs one conversation at a time. The actual working setup is a dual-screen desk: one screen for a browser — testing, watching CI, reading the shared case record directly — and the other running several parallel agent sessions at once, each with a distinct, consistent role: one field reporter, one backend engineer always present, a second backend session dedicated to working through the smaller, non-strategic backlog, and an app-focused session alongside them. A further two virtual desktops run in the background: one dedicated to an agent managing the underlying home-network infrastructure, another running a small fleet dedicated purely to working through the case backlog.
It didn't start this way. It grew because waiting on one slow response felt wasteful — so a second session started, then a third, and the parallel setup is the accumulated answer to "I'm waiting anyway, I might as well start another thing."