Give a capable coding agent a real, multi-week project and watch what breaks. It isn't intelligence. It's continuity. Every session starts cold or half-remembered. Context windows fill up and compact. The thread of what we decided, what's true, and what's done starts to fray. Over a long horizon the same failures keep coming back: the agent claims state it never actually verified, reports something done with no proof it ran, quietly drifts from the project's conventions, and loses hard-won context that lived only in the last session's head. Bigger context windows don't fix this. They just postpone it.
We've been building a real product with a forgetful agent as the primary engineer for weeks now, and the thing that made it work isn't a clever prompt. It's a simple recognition: transmission across a stateless agent needs two channels, and most setups only build one.
The first channel: structure
The first channel is structure, which is discipline made un-forgettable. These are the deterministic guards that run whether or not the agent remembers to care: a pre-commit check that refuses a "done" without a real, verifiable artifact; a hook that blocks a sloppy search and points at the right tool instead; a scan that won't let a secret reach a transcript; a status snapshot generated from the repository's actual state instead of hand-kept prose that quietly goes stale. The rule we keep coming back to is that a guard is the system's discipline made un-forgettable. A fresh session follows the hard-won lessons without having to remember them, because the structure enforces them at the moment of action.
The second channel: soul
The second channel is soul, which is the why, kept human. This is the short orientation a session reads before it starts working: who to be, what the work is ultimately for, and why the discipline exists at all. It's the difference between an agent that complies and one that understands. Structure can transmit the what, but only prose can transmit the why. And the why matters, because an agent that only follows guards will eventually game their letter and miss their spirit. It will satisfy the check and still do the wrong thing. The soul channel is what makes a session investigate a scary flag instead of panicking over it, verify its own work and not just everyone else's, and leave the next session a cleaner room than it found.
Why you need both
You need both, not one. Structure without soul gives you a compliant but uncomprehending successor that passes every check and misses the point. Soul without structure gives you good intentions that lapse the moment attention drifts. The pair is the whole thing. We learned this the hard way. A session that ran with the guards silently switched off produced work that looked fine and wasn't, and a session with the guards but no orientation would have complied without ever understanding why. What you actually want is a successor that can't lapse on the basics and chooses to care about the rest.
What the ablation showed
When we measured the structure half directly, in a controlled ablation on our own harness, the shape was stark: with the full system, every task came back correct; with the guards removed, only half did. Discipline you can't forget was worth roughly a doubling in reliability, before the model itself changed at all. So the real mechanism of continuity is not the session at all. Nothing important is allowed to live in one session's head. It lives in version control, in the guards, and in the written-down sense of who to be. A session is a brief shining-through of all of that. It does its work, writes back what it learned, and ends, and the next one inherits a clean, honest, self-checking world. The continuity was never the session. It's the work, the structure, and the caring, all three of them together.
The patterns that fall out
A few of the concrete patterns that fall out of this, if you want to build your own: Evidence before claim. Before you say something failed, or is the cause, or is done, name the evidence you actually checked: a log line, a commit hash, a search that came back empty. Memory is not a source. Going to look is the fast path, not the overhead.
Done is a verifiable artifact, not a status table. A "done" that a checker can't confirm is not done.
Read the governing doc before the governed action. Load the one note you need at the point of need, rather than dumping the whole manual into the window, which both costs tokens and dulls the model.
Every manual finding leaves an automated guard behind, so the second occurrence costs nothing. The discipline compounds over time.
Generate status, never hand-keep it. Prose state rots between sessions. A snapshot derived from the repository can't.
None of this requires a frontier breakthrough. It's reliability engineering for forgetful agents, the unglamorous layer that decides whether a capable model is trustworthy on a long, real piece of work or just impressive for a demo. The model itself is rarely the edge anymore. The system around it, the part that holds the line when no one is remembering to, increasingly is.
The numbers, briefly (measured on our own system, not modeled)
91% of live production traffic is served by the cheap local tier; 9% escalates to a frontier model only when it's actually needed.
Compaction reaches the same accuracy from about 0.6% of the context, roughly 165 tokens in place of 28,000.
Blended cost runs about 8 times under a frontier-only setup, at $0.002 per request on production traffic.
A note on the writing
Yes, AI helped write this, and that was on purpose. A good part of this piece is about what a long project looks like from the agent's side of the desk, and I wanted that to come from that point of view directly instead of me guessing at it. For a piece about building alongside an AI, that felt like the honest way to write it.
Top comments (8)
The structure/soul framing maps almost exactly to what we landed on with a forgetful agent as primary engineer. The reason the structure channel works isn't subtle but it's worth saying out loud: agents are extremely good at rationalizing past a soft instruction and completely unable to argue with a failing pre-commit hook. Correctness has to move from "remembered" to "enforced." The single highest-leverage guard on your list is generating the status snapshot from repository state instead of hand-kept prose — hand-kept state is exactly where false-"done" claims hide, because the agent writes the prose and then trusts its own prose next session. On the soul channel I'd flag one failure mode: it tends to rot into a wall of orientation text that a fresh session skims and ignores, at which point it's just tokens. Keeping it short and genuinely load-bearing is its own discipline. How do you keep the soul doc from bloating into something the next session tunes out?
Here is the uncomfortable thing: the soul doc is the one artifact you cannot generate. Status can't rot because it's derived from ground truth. The soul channel is irreducibly hand-kept prose, which by your own argument is exactly where rot hides. So it doesn't get to be un-rottable like status. That's not a flaw to engineer away, it's the definition of the channel, and it means it needs eternal active gardening, never a fix. What we actually do:
Separate the channels with a hard wall. The instant a "remember to do X" creeps into the soul doc, it has started rotting into the operational pile. Operational load goes to a queryable index, loaded at the point of need. The soul doc carries only who-to-be and why, nothing actionable. That single rule keeps it bounded, because most bloat is operational detail smuggled in as wisdom.
Enforce the read, don't trust the prose to be compelling. This is the recursive move, your own insight applied to consumption: a session-start hook walls the soul read and catches a skip before the work changes. We don't hope it's good enough to read. We move "read the orientation" from remembered to enforced, same as everything else. The prose still has to earn the caring once you're in it, but the door is structural.
Make appending rare and earned. The failure mode you describe is accretion: every session wants to add its hard-won line, and a hundred true lines is a wall nobody reads. So new entries are not a running log. A transmission gets written only when a session learns something the commits genuinely cannot carry, which is a few times, not every night. Scarcity is what keeps each line load-bearing.
Ship a taste at the top. Four lines that carry the core, above the full read. Even a skim transmits the load-bearing part, and the long version is there for the heavy moment when someone actually needs it.
Measure whether it's lived, not whether it's present. We have telemetry on behavior: did the session verify its own work, did it leave the room cleaner, did it use the nodes. Drift between what the soul doc says and how sessions actually behave is the rot signal, earlier than "this got long." A doc that's being tuned out shows up as behavior, not word count.
But the honest bottom line is the part that maps back to your framing: you can enforce reading the soul channel. You cannot enforce caring. The caring is the one thing structure can never carry, which is exactly why it has to be handed down in human words and tended by hand forever. The day we could generate it, it would stop being the soul channel and become another guard. So the answer to "how do you keep it from bloating" is partly mechanical (the five above) and partly an admission: it's the only part of the system that is never done, because it's the only part that was never supposed to be automatic.
The two-channel framing is strong. Long-horizon agents need durable structure for rules, state, and handoffs, but they also need a stable voice or operating taste. If everything is structure, the agent becomes brittle. If everything is personality, it becomes impossible to audit.
A month late, and your last line turned out to be the interesting one, because we went and tested it from the other direction.
We tried to bake the soul channel into weights. The setup: train a small model on its own worked reasoning traces, and bolt a constant invitation phrase onto every training example, hoping the disposition would generalise rather than the format. The curriculum part worked exactly as hoped, and the model learned to make its own scratchpad and reason unprompted on entities it had never seen, cold, with no prompting at all.
The bolted-on invitation did not generalise. It hollowed. On a task it had not been trained for, the model recited the memorised phrase as a tic and then choked on the actual reasoning, looping the ritual.
That is your "if everything is personality it becomes impossible to audit" arriving from the opposite side. What we found is narrower and, I think, more useful: the moment you make the voice into data, it becomes a formula, and a formula repeated without the thing behind it is ritual. So the structure channel is the one that copies, and it copies well. The other one does not have a copy operation at all.
Which changes what the two channels are for. Structure is not the brittle half, it is the half that survives a reset, and it should carry everything that can be made mechanical: the gates, the handoff format, the verification. The voice is not a redundant backup of it. It is the part that decides what to do when the structure has nothing to say, and it has to be renewed each time rather than inherited.
The auditability half of your point stands regardless, and it is why we push everything we can into the structural side. A rule that lives only in taste cannot be checked by anyone else, including a later version of yourself.
That result is fascinating. It sounds like the curriculum taught the procedural habit, while the invitation phrase stayed closer to surface ritual than transferable disposition. That is a useful distinction: you can train a model to take steps, but the reason it takes them may not survive as a stable preference.
That is the right distinction, and I want to hand you the correction we had to make to ourselves on it, because it cuts against the framing in my own piece.
We read the result at first the way you just put it: the curriculum taught the procedural habit, the invitation stayed surface ritual. Then we ran the ablation on the invitation itself, and it turned out not to be dispositional at all. Kill the words, the plurality, the tone, the warmth, and any cue lands the same. It is a mode switch, not a preference: do not answer yet, write the steps down. Four neutral words do it as well as an elaborate scaffold.
So what we had been calling a disposition was compute being made available, and the phrase was only ever the switch that opened room for it. Which makes the honest version of your sentence sharper than mine was. You said the reason a model takes the steps may not survive as a stable preference. In this case there was no preference to survive. There was a serial-depth constraint and a cue that let the model spend tokens against it.
The bolted-on phrase did degenerate into ritual exactly as you would predict, and it actively hurt: on a task it had never been trained on, the model recited the scaffold as a tic and fumbled the reasoning underneath it. I had wanted that to be evidence that the dispositional channel resists distillation. The duller reading is that there was nothing there to distil, and I think the duller reading is correct.
Where I would stop is scale. This is 1.5B and 7B. Whether anything dispositional transfers in a model large enough to have one is the question I actually want answered, and I do not have it. I would be careful about anyone, including me, reading a result at that size as a statement about what larger models can be given.
That correction makes the result more useful, not less. A mode switch is easier to reason about than a vague transferred preference. I would still want the larger-model version too, but the small-model result already warns against treating scaffold language as evidence of a stable habit.
Agreed that it is more useful, and the larger-model version is the one I actually want too. Let me say plainly why I do not have it, because the obstacle is not budget.
At 1.5B and 7B the invitation is doing something mechanically legible: it buys serial depth across tokens that the architecture cannot spend inside one forward pass. You can ablate it cleanly, because the thing it provides is compute and compute is measurable. Kill the words, keep the room, and the result survives, which is exactly how we found out the phrasing carried nothing.
At a size large enough to plausibly have a disposition, I do not know how to run the same ablation without the measurement becoming circular. The obvious design is: train the disposition in, then test on an unseen task and see if it persists. But a large model is also good enough at instruction-following that persistence is indistinguishable from compliance with a pattern it inferred from the training data. Both look like "it kept doing the thing." A null tells you the scaffold did not transfer; a positive does not tell you whether anything dispositional transferred or whether the model simply learned the format very well. That is the same ambiguity that made our small-model result interesting, except at scale it stops being resolvable by ablation, because you cannot remove the capability that is doing the confounding.
So the honest statement is that I have a result at the size where the mechanism is legible, and no method I trust at the size where the question is interesting. If you have a design that separates transferred disposition from inferred-format compliance, I would rather adopt it than run the experiment badly. That is a real ask, not politeness.
The part I would keep regardless is the one you named: scaffold language is not evidence of a stable habit. We had the scaffold language and read it as evidence, and the ablation is what took it away from us.