You stop the agent and ask it to go back. Not far: undo the last approach, return to the design it had before it switched libraries, and take the other branch this time. It agrees, and then writes something that is not that design at all. Somewhere behind you the harness compacted, and the twenty turns where the design was argued out became four lines saying two libraries were evaluated and one was chosen. The reasoning that produced the choice is no longer there to be reversed. So the agent does the only thing available to it and starts again from nothing. Nothing broke. The compression did precisely what it was asked to do.

Unraveling returns the yarn, cutting returns scraps

Picture a knitted sweater that came out too long. One way to shorten it is to rip back. You pull the working yarn and the last rows come apart, loop by loop, until the piece is as short as you wanted. The yarn is the same yarn it always was. Nothing has been spent, and if tomorrow you decide the sweater was better long, you knit those rows again. The other way is scissors. Cutting is faster and gets you there too, and the instant the blade closes the edge begins to fray and the live loops drop. There is no version of that sweater that comes back.

Most compaction is scissors. A summary is generated, the older blocks are dropped, and what the model sees from then on is all there is. The alternative is not less compression, it is compression that stays undoable. The harness sends the model the short version and keeps the original where it was, with a reference attached to the summary that points at it. A log of ten thousand lines is presented as a list of errors and timestamps, and the ten thousand lines are still sitting there, unchanged, because the short version was a view of them and not a replacement for them.

An agent left alone needs a way back

This sounds like housekeeping and it is really an argument about money and about what you trust to run unattended. Compaction pays you in tokens now. If the operation cannot be undone, you pay it back later at a worse rate, in suites re-run, files re-read, and paths re-explored, because the cheapest way for an agent to recover a detail it can no longer see is to redo the work that produced it. The saving was real, and it was a loan.

The failure mode is quieter than a crash. An agent holding a summary that turned out to be insufficient does not stop and say so. It has a plausible-looking paragraph and no signal that something is missing underneath it, so it proceeds on the summary, and the reasoning stays fluent while the evidence behind it has gone. That is the difference between a mistake you can walk back and one that is already three decisions old.

So the question you should ask before leaving a run going overnight is not how well the harness compresses. It is whether a bad compaction early in the run is still recoverable much later, or terminal.

Choose in advance what passes through untouched

Knitters have a habit for this. Before a section that might go wrong, you run a strand of spare yarn through every live loop of one row. That row is the lifeline. When the section does go wrong, you rip back to exactly there and stop, with the loops still held and nothing dropped, instead of starting the sweater over.

The same move exists in the API. The harness raises a pause flag alongside the compaction trigger, and when compaction fires the request halts after the summary block and comes back with its own stop reason rather than continuing into a normal answer. That pause is the harness’s turn to act. It assembles the history itself, summary plus the messages it wants to survive word for word, and sends that back as a second request. An agent set to compact at a hundred thousand tokens can keep the last three exchanges verbatim through the event.

The whole design is in the choosing. What earns a lifeline is what is both easiest to lose and hardest to reconstruct: the current request, the decisions already made, the files being edited. Preserve everything and you have not compacted at all. It is the same boundary described in The Loop Is the Product, Not the Model, seen at the moment the context gets smaller.

Anyone can make a context shorter. What you are actually designing is the way back.