The Persistence Gap: Why Agent Work Products Vanish

95 telemetry events. 13 subagent dispatches. A governer score of 74. Every structured artifact field: null.

Case Study · Next AI Labs · Human-Agent Research · 9 min read

A single agent session produced 95 telemetry events, dispatched 13 subagents, scored a task at 74 out of 100 on our leverage scale, and captured 4 verbatim user requirements. When we queried the session record afterward, every structured field was null.

Not corrupted. Not failed. Null. The fields existed in the schema. 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 scope declarations, negotiate verification contracts that define what "done" means, score each task through a leverage pipeline that weights autonomy impact against human-development alignment, 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 scoring pipeline returns structured JSON, the verification contracts are well-formed, the verbatim capture deduplicates by content hash. 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:

• 95 telemetry events logged to a local JSONL file
• 1 governer score of 74 (high-leverage, plan-gated work)
• 13 subagent dispatches, each with its own scope
• 4 verbatim user requirements captured with MD5 deduplication
• 23 user prompt submissions processed through the enrichment pipeline
• 3 evidence gate blocks (the system caught the agent claiming completion without proof)

What survived in the session record:

• workProducts: null
• evidence: null
• commits: null
• completedItems: null
• planSnapshot: null
• governerTraces: null
• subCompactions: null

Seven structured fields. All null. The schema had been designed months earlier with exactly these fields, anticipating exactly these artifacts. The agents had been instructed to populate them. The API accepted writes to every one. 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 scoring this task, POST the score 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 directive through a hook. 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 13 subagent dispatches and 23 user interactions has a context window that is filling with immediate concerns. The directive to POST the governer score 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.

  INTENDED WORKFLOW          WHAT ACTUALLY HAPPENS
  ─────────────────          ─────────────────────
  Agent scores task    →     Score returned as JSON ✓
  Score written to DB  →     [soft gate: agent must POST]  ✗
                             Agent proceeds to next task.
                             Score lives in context only.

  Agent writes plan    →     Plan produced as markdown ✓
  Plan stored in       →     [soft gate: agent must POST]  ✗
  session record             Plan lives in context only.

  Agent captures       →     Requirements captured ✓
  user requirements          with MD5 dedup
  Requirements linked  →     [soft gate: agent must POST]  ✗
  to session record          Requirements live in /tmp only.

  Subagent completes   →     Work product produced ✓
  Work product linked  →     [soft gate: agent must POST]  ✗
  to parent session          No child records created.

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 with a governer score of 74 should have produced a plan (scores above 50 trigger a mandatory planning gate). 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 governer score of 74 should inform future scoring calibration. The verification contract 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 hooks).

We identified three categories of capture that needed to become automatic:

1. Event-driven capture. When the scoring pipeline returns a result, a post-hook 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 session boundaries — start, compaction, and end — extraction hooks scan for artifacts that were produced but not yet persisted. This is the safety net for anything the event-driven hooks missed.

3. Relational capture. When a subagent completes, its work products are automatically linked to the parent session record via bidirectional ID references. The schema already supported this (parent and child ID arrays with append-on-write merge semantics). The missing piece was the trigger.

  REVISED WORKFLOW             HOW IT WORKS
  ────────────────             ────────────
  Agent scores task      →    Score returned as JSON ✓
  Post-hook fires        →    POST to session record  ✓
                              [infrastructure, not agent]

  Agent writes plan      →    Plan produced as markdown ✓
  Lifecycle hook at      →    Extracts plan, POSTs to   ✓
  session boundary            session record

  Subagent completes     →    Work product produced ✓
  SubagentStop hook      →    Creates child record,     ✓
  fires                       links to parent

Before and After: One Session, Measured Twice

We backfilled the audited session using the new capture infrastructure to measure the difference.

Before (soft gates only): | Field | Value | |---|---| | workProducts | null | | governerTraces | null | | planSnapshot | null | | completedItems | null | | subCompactions | null | | evidence | null | | commits | null |

After (infrastructure capture): | Field | Value | |---|---| | workProducts | 8 items: 3 governer traces, 2 verification contracts, 2 research reports, 1 verbatim requirement set | | governerTraces | 1 trace: score 74, SILA weights (autonomy-capability: 7, human-potential: 4, ecosystem-wellbeing: 3) | | planSnapshot | 1 plan linked to the score-74 task | | completedItems | 4 tasks, 3 linked to plans | | subCompactions | 2 child records with bidirectional parent links | | evidence | 3 evidence-gate events with pass/fail status | | commits | 5 commits within session time window |

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 produced 8 work products, 1 governer trace, 4 tasks, and 2 child records. At 50 agent sessions per day, that is 750 new records daily. 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 seven null fields — or by asking why your agents never seem to get better.