The Persistence Gap: Why Agent Work Products Vanish
95 telemetry events. 13 subagent dispatches. A governer score of 74. Every structured artifact field: null.
Agents produce structured artifacts every session. Without auto-capture infrastructure, those artifacts vanish on session end. We audited one session to measure exactly what was lost, then built the infrastructure to fix it.
Next AI Labs · Human-Agent Research
A single agent session did a great deal of structured work: it planned, delegated to other agents, judged how much the task mattered, and captured the person's exact words. We found an audited session had left almost nothing behind, because recording the work depended on the agent remembering to; so recording now happens at the moments work changes hands, not by request.
Not corrupted. Not failed. Empty. The places to keep the work existed. The agent had produced the artifacts. Nothing had written them down.
The Oral Tradition Problem
Modern agent systems are sophisticated producers of structured work. During a typical session, our agents generate plans with a declared scope, agree in advance on what "done" means, judge how much each task matters, and record the exact words the user said — not a summary, the verbatim text.
All of this exists in the conversation context. And all of it vanishes when the session ends.
We call this the Persistence Gap — the delta between what agents produce and what survives. It is not a bug in any individual component. Every piece works: the judging step returns a clear result, the agreements about what "done" means are well-formed, the capture of the person's exact words is reliable. The gap is between components. Nothing moves the artifact from where it is produced (the conversation) to where it needs to live (the database).
This is the alignment equivalent of oral tradition. The knowledge is rich, contextual, and specific. It is also completely unreproducible once the conversation closes.
What We Found When We Looked
We audited a specific session — one with above-average complexity — to measure the gap precisely.
What the session produced: a plan for high-stakes work, a judgment of how much that work mattered, tasks delegated across more than a dozen helper agents each with its own scope, the person's exact requirements, and several moments where the system caught the agent claiming completion without proof.
What survived in the session record: nothing structured. No record of the work products, the evidence, the commits, the completed tasks, the plan, the judgment, or the helper agents' reports.
Every place we had set aside to keep this work was empty. The record had been designed months earlier with exactly these artifacts in mind. The agents had been instructed to fill it. Every part of it was ready to accept the work. Nothing connected the production of the artifact to the persistence of the artifact.
The Soft Gate Failure Mode
When we traced the root cause, we found a pattern we now call the Soft Gate problem.
A soft gate is an enforcement mechanism that works by instructing the agent to do something — "after judging this task, save the result to the session record" — rather than making the infrastructure do it automatically. Soft gates are easy to build. You add a line to the system prompt or inject a reminder at the right moment. The agent reads it, understands it, and complies. Usually.
The failure mode is not refusal. It is forgetting. An agent handling a complex task with many delegated helper agents and many user interactions has a context window that is filling with immediate concerns. The instruction to save the result to the session record is competing for attention with the actual work of responding to the user, verifying outputs, and managing subagents. The instruction exists. The agent processed it. But at the moment of artifact production, the agent is focused on the artifact itself — not on the persistence step that follows.
This is not unique to AI agents. Humans exhibit the same pattern. A developer who writes excellent code but never commits it. A researcher who produces insights in conversation but never writes the paper. The work exists. The record of the work does not.
The difference is that for human work, we solved this decades ago. Version control does not ask developers to remember to save their code. It captures changes automatically as they are produced. The developer's job is to write code. The infrastructure's job is to persist it.
Six Gaps, One Pattern
We mapped the full intended workflow for how agent artifacts should flow from production to persistence, and found six specific gaps. Every one followed the same pattern: the schema was ready, the API endpoint existed, and the instruction to the agent was present. The connection between them was a soft gate.
Take any of the work an agent produces: a judgment of how much a task matters, a plan, the person's exact requirements, a delegated helper's finished work. In each case the work was produced correctly. In each case, writing it down was a separate step the agent had to remember. The agent moved on to the next task, and the work lived in the conversation only.
The pattern: production works, persistence depends on the agent remembering an extra step, and the agent is focused on the work itself. The result is Artifact Ephemerality — structured artifacts that are queryable in theory but ephemeral in practice.
What Happens When Artifacts Vanish
The immediate cost is obvious: you cannot audit what you cannot see. A session on high-stakes work should have produced a plan (work judged high-stakes requires one). Whether that plan was produced and was good, or was produced and was poor, or was never produced at all — we cannot tell. The evidence is gone.
The deeper cost is to Compound Learning. Every session that produces artifacts but does not persist them is a session that the next agent cannot learn from. The judgment of how much the task mattered should inform how future tasks are judged. The agreement about what completion means should become a template. The verbatim user requirements should feed back into intent alignment. None of this happens when the artifacts vanish.
This creates a specific failure in the Alignment Feedback Loop. The loop depends on four steps: the agent acts, the human corrects, the correction is captured, and future agents receive the correction. Steps one and two work. Step three — capture — is where the persistence gap breaks the loop. Without captured artifacts, corrections apply only to the current session. The next session starts from zero.
The compounding effect is severe. An agent system that persists its work products improves session over session. An agent system that does not persist them has no mechanism to improve at all. The quality ceiling is whatever a single session can achieve with no prior context.
The Fix: Infrastructure-Level Capture
The solution is conceptually simple and operationally specific: move artifact persistence from soft gates (agent instructions) to hard gates (infrastructure that acts on its own).
We identified three categories of capture that needed to become automatic:
1. Event-driven capture. When the judging step returns a result, the infrastructure writes it to the session record. The agent does not need to remember. The infrastructure observes the event and persists the artifact.
2. Lifecycle capture. At the boundaries of a session — its start, when its context is condensed, and its end — the infrastructure looks for artifacts that were produced but not yet persisted. This is the safety net for anything the event-driven capture missed.
3. Relational capture. When a subagent completes, its work products are automatically linked to the parent session record, with references running in both directions. The schema already supported this. The missing piece was the trigger.
In each case, recording moved from a request made to the agent to something that happens at the moment work changes hands: when a judgment is returned, when a session reaches a boundary, when a helper agent finishes. The agent's job is the work. The infrastructure's job is to keep it.
Before and After: One Session, Measured Twice
We backfilled the audited session using the new capture infrastructure to measure the difference.
Before (recording by request): every part of the record was empty.
After (recording at the moments work changes hands): the same session now carries its work products, the judgment with its reasoning, the plan linked to the task it served, the completed tasks linked to their plans, the helper agents' records linked to the parent session in both directions, the moments the system caught an unproven completion claim, and the commits made during the session.
The same session. The same agent. The same work. The difference is whether anyone built the shelves.
What We Still Do Not Know
1. What is the right granularity for auto-capture? We are currently capturing at the artifact level (each plan, each score, each contract). But some sessions produce dozens of intermediate artifacts that may not be worth persisting individually. We do not yet know where the signal-to-noise threshold falls, and over-capturing could make the session record as noisy as under-capturing makes it empty.
2. Does infrastructure-level capture change agent behavior? When agents know their work products are automatically persisted, they may produce artifacts differently — more carefully (because they are auditable) or more carelessly (because persistence is no longer their responsibility). We have not measured this yet.
3. How do you handle conflicting artifacts? A session that changes direction midway produces a plan for the original scope and a different plan for the revised scope. Both are valid artifacts. Auto-capture persists both. But which one represents the session's actual intent? We do not currently distinguish between superseded and final artifacts.
4. What is the cost of artifact storage at scale? A single session with infrastructure capture left a record for every piece of work it did, and many sessions run each day, so the records add up quickly. We have not stress-tested the query patterns that make this useful rather than overwhelming.
5. Can the persistence gap re-emerge at a higher level? We fixed the gap between conversation context and the session database. But the session database is itself a local system. If the insights in those records are not surfaced to the right agent at the right time, we have moved the gap rather than closed it. The Zero Touch Observability question — whether opening the admin page is sufficient to see what matters — remains open at the cross-session level.
The Lesson
Telling agents to save their work is like telling developers to remember to commit. It works when the task is simple and the context window is clear. It fails exactly when it matters most — during complex, high-leverage work where the agent's attention is fully consumed by the task itself.
The fix is not better instructions. It is better infrastructure. Capture at the point of production, not at the point of remembering. Make persistence the default, not the extra step.
Every agent system that depends on agents to persist their own artifacts will eventually discover the Persistence Gap. The question is whether you discover it by auditing a session record and finding nothing recorded — or by asking why your agents never seem to get better.