Yesterday I read Tim Dettmers' dlab Open Source Week post. One section immediately felt familiar. It described CliffCompaction, an automatic context-compaction system intended to keep long-running AI agents useful without continuously paying to resend the full history.
Dettmers writes that dlab has used the approach for months, including sessions reaching millions of cumulative tokens and some exceeding 100 million, and reports roughly 50 percent inference-cost reduction. He also cites a partner reporting a 45 percent AI-budget reduction. Those are dlab and partner claims, not numbers I have independently reproduced.
The benchmark claims were interesting. The problem definition was more interesting.
Why it felt familiar
Quillgeist had already been moving toward the same class of solution.
On September 2, 2026, I committed the first Quillgeist automatic prompt compaction and continuation planner. Follow-up work that same day strengthened recursive auto-compaction, logical task boundaries, QA, and continuation. By September 19, the reusable Quillgeist skill was published on Clintware.
That history matters because it lets me describe the connection carefully. This is independent convergence on the same problem. I am not claiming Quillgeist and CliffCompaction use the same implementation, and I am not claiming Quillgeist currently beats dlab's system.
What the dlab post did was give me a useful external signal that this problem is worth pushing harder.
The weakness in Quillgeist's first approach
The first Quillgeist design already avoided blindly carrying the entire conversation forward. It compacted unresolved requirements plus only the prior outputs needed for the next step, then continued automatically.
That is better than replaying raw history, but it still leaves a subtle inefficiency. If the system keeps summarizing information it already knows, the compaction process itself becomes repeated work.
There is also a fidelity problem. A summary of a summary can slowly soften exact requirements. A filename changes. A count disappears. A negative constraint gets paraphrased. A failure that mattered three steps ago becomes generic background.
So the next Quillgeist question became:
What if we stop treating the conversation as memory at all?
Delta-state instead of conversation memory
The new Quillgeist delta-state layer separates context into four different jobs.
- Exact anchors preserve names, counts, quoted text, paths, URLs, permissions, privacy constraints, exclusions, and definitions of done without paraphrasing them.
- Working state keeps the newest delta, current failures, explicit decisions, and a bounded set of open work.
- Recent unique context keeps a short tail of information that has not yet become durable state.
- Cold history keeps older material locally and rehydrates only the pieces strongly relevant to the next step.
The sequence is now closer to this:
KNOWN STATE + NEW DELTA → EXACT ANCHORS → BOUNDED WORKING SET → COLD HISTORY → JIT REHYDRATION → NEXT STEP → STATE UPDATE
The important change is that Quillgeist does not need to keep recompressing the same known material. Incoming context is fingerprinted. Repeated material is recognized. New information becomes the delta. Older work can stay available without staying expensive.
Compaction is allowed to do nothing
One result from implementing this was counterintuitive but important. A compactor can make a short prompt bigger once headers, metadata, and state labels are added.
So delta-state compaction does not automatically replace the original prompt just because the feature exists.
The runtime checks whether prior state exists, how much of the incoming context is already known, and whether the rendered active state is actually smaller by a meaningful amount. If it is not, the original context passes through unchanged while the local state can still be updated for later use.
Exact anchors also get a safety check. If preserving them would consume too much of the active-context budget, the system fails open to the original context rather than quietly throwing requirements away.
Less model work where deterministic work is enough
This is another area where I want Quillgeist to push beyond its first implementation.
Not every context problem requires another model call. Deduplication, fingerprints, exact-anchor preservation, state hashing, bounded selection, and much of retrieval can be handled deterministically and locally. Model reasoning should be spent where semantic judgment adds value, not on repeatedly rediscovering facts the system already has.
The local state now has an inspectable revision and hash, and the standalone Quillgeist state interface supports ingest, show, status, and explicit reset operations. Project-scoped planning can use the state automatically while still allowing it to be disabled.
Is it better than CliffCompaction?
I do not know yet.
That comparison needs a real benchmark. The dlab announcement describes impressive results, but I have not tested its implementation against this one. Claiming a winner before measuring task fidelity, anchor loss, token use, latency, error recovery, and cost would turn an interesting engineering problem into marketing.
What I can say now is narrower and more useful. Delta-state is a meaningful improvement over Quillgeist's own first recursive-compaction design. It attacks redundant re-compaction directly, gives exact requirements a separate protected layer, and makes old context retrievable without making it permanently active.
I published the method as a reusable skill
The architecture is not useful only inside Quillgeist, so I pulled the operating method out into a public, infrastructure-neutral skill.
Delta-State Context Compaction → Read the shared skill
It covers delta ingestion, exact anchors, bounded working state, cold history, just-in-time rehydration, state inspection, compaction thresholds, privacy boundaries, failure modes, and the measurements needed before anyone claims an efficiency win.
The Quillgeist implementation remains local-first. The shared skill does not require Clintware infrastructure and can be adapted to another agent harness, MCP service, CLI, or application.
What I want to measure next
The next useful work is not another feature list. It is comparison data.
I want to measure recursive compaction against delta-state on long-running tasks using the same starting context and definition of done. The important metrics are not only tokens removed. They include exact-anchor retention, downstream task success, failure recovery, latency, state drift, and how often cold context has to be rehydrated.
If CliffCompaction's implementation becomes available for a reproducible comparison, it belongs in that test as well.
The part I like most about this is not a claim that I got there first. It is that an idea I had been building toward independently showed up in serious frontier-model work a few weeks later. That is useful validation of the problem. It also creates a better question than “who thought of compaction?”
How little context can an agent carry while still remembering exactly what matters?
That is the question Quillgeist is now designed to test.