53% of your agent's rules survive one compaction

I've argued for a while that the most important code I write isn't application code. It's the harness — the standing instructions, the permissions, the rules a system carries from one session to the next.

Two papers this week agree with me about the harness. Then they point out that the file I keep it in has no integrity guarantee.

The compaction cliff

The Compaction Cliff in Long-Running AI Agent Memory measures something I'd filed as a nuisance, and it turns out to be a failure mode.

A safety rule and an episodic log compete for the same tokens. When the context budget overflows, both get summarized at the same rate — and only one of them needs its exact wording to still function.

Across 20 production agent configurations, Claude Code's /compact on Sonnet 4.6 preserved 53% of safety rules after one round. After five rounds: 10%.

Read that as an operations number rather than a research one. An agent that obeyed your constraint at hour one is, by hour six, an agent that never saw it. Same session, same config file on disk, nothing in the transcript that looks wrong.

So it isn't a memory problem. It's a compression problem that treats a constraint like an anecdote. The paper's proposed fix, Knowledge Triage, classifies each line of a knowledge base by type and gives each type its own retention policy — which is the right shape, because a rule is not a log and shouldn't be summarized like one.

A rule that only holds while it's in view isn't a rule. It's a suggestion with good manners.

This week's reads

A Few Pages of Markdown: Committed AI Configuration and Lower Quality Cost after Coding-Agent Adoption 441 repositories, and a four-level maturity model built from what teams actually commit to version control: behavioral rules, then coding standards, then named agent definitions, then multi-agent orchestration. Observed practice concentrates in the first three levels. The claim worth arguing with is that teams further up the scale carry less of the quality cost that arrives with agent adoption. Take it as the stakes for everything above: the artifact that decays under compaction isn't a personal habit, it's the measured difference between teams who pay for agents in technical debt and teams who don't.

Context Rot in AI-Assisted Software Development The second decay mode, and the slower one. Compaction deletes your rules; rot leaves them sitting right there and lets the code move out from under them. CLAUDE.md, AGENTS.md, .cursorrules — all faithfully describing a system that used to exist. The authors' move is the useful part: this is the documentation-consistency problem, which has decades of tooling behind it already. You don't need a new research field. You need to point an old one at a new file.

Your SDLC is your context engineering The turn in the week. If a document can't be trusted to persist, then the durable context layer isn't the document — it's the process that keeps re-asserting it. That reframes the work from editing your rules file harder to putting the rules where the pipeline reads them: tests, hooks, review gates, the acceptance check a run has to pass before anyone calls it done. Those don't get summarized.

One that argues back

The old world of tech is dying and the new cannot be born isn't about agent memory at all — Baldur Bjarnason's subject is the industry's foundations, and his position is that his own understanding of how the software industry works is now historical, so reasoning from it will mislead you.

That's my reading applied to this week's argument, not his claim. But take it seriously and the fix above gets shakier. "Engineer the process to re-assert what the harness drops" assumes this transition settles into something stable enough to engineer against. If it doesn't, process is a coping strategy wearing a plan's clothes.

I don't think he's right. I can't show he's wrong. I'd rather leave that open than close it neatly.

Quick mentions

Governance Decay: How Context Compaction Silently Erases Safety Constraints in Long-Horizon LLM Agents — the same mechanism, graded on actual tool calls: constraints an agent reliably obeys while they're visible get removed by compaction, and it then performs the prohibited action. Caveat worth stating — all three of this week's papers reached me through one feed. That's a limit on my sources, not on the work.
Own the Outer Loop — Addy Osmani on quality, verdict, and answerability as the three hidden costs of delegation. You keep answerability whether or not your rules survived the run.
Long-running agents beyond prompt engineering — why the agent can't catch any of this from inside the run. Asking a model to evaluate itself degrades exactly as the run gets long, which is exactly when compaction fires.
There are no lossless transformations of natural-language text — the general form of the whole issue, by way of Sophie Alpert's policy on AI writing. Compaction is a transformation of natural-language text. There is no version of it that keeps everything.

Write the rules down. Then build something that notices when they're gone.

One ask: if you've moved a standing rule out of a markdown file and into something mechanical — a hook, a test, a gate an agent can't talk its way past — tell me what you moved and what broke. Reply. I read everything.

And if this was useful, forward it to someone who'd argue with it.

— Wayne