Narrative Is an Epistemic Compression Format

When an AI agent tries to solve an interactive, multi-step problem—whether playing an unfamiliar rule-discovery puzzle, diagnosing a distributed systems bug, or exploring a codebase—it almost immediately collides with a structural dilemma that has nothing to do with raw model intelligence.

The dilemma is what to do with its own thinking.

In modern agent harnesses, reasoning typically unfolds across multiple sequential passes: the model thinks, decides on an action or a tool call, inspects the environment’s response, and thinks again.

Between those passes, standard system architectures force a choice between two bad defaults:

1. Amnesia (The Discarded Scratchpad): After each tool call or environment step, the harness discards the private chain-of-thought tokens that led to it. Only the public action and the environment’s observation are preserved in the conversation history.
2. Context Bloat (The Verbatim Tape): The harness retains all reasoning tokens across passes, concatenating each round’s stream-of-consciousness scratchpad into the next prompt.

Both defaults fail catastrophically on hard tasks, and they fail for complementary reasons.

The Two Traps

The amnesic default forces the model to re-deduce the universe from scratch after every single action. If an agent spends two thousand thinking tokens deducing that a system failure is caused by a race condition in a thread pool rather than a memory leak, and then calls a diagnostic tool to verify the thread state, discarding those reasoning tokens leaves the model stranded on the next turn. It sees only the diagnostic output. To understand what the diagnostic output means, it must spend another two thousand tokens re-deriving the hypothesis it had already established. In complex rule-discovery environments—like the interactive tasks in ARC-AGI-3—this amnesia turns every step into a first encounter. The agent cannot build a stable world model because its working theories vanish the moment it acts.

The verbatim default attempts to solve this by keeping everything. But in a multi-pass task involving ten or fifteen tool calls, accumulating raw scratchpads creates an $O(N^2)$ explosion in processed tokens. More dangerously, it poisons the model’s own attention. A model generating thousands of reasoning tokens per pass inevitably explores blind alleys, makes arithmetic slips that it later catches, and wanders down speculative dead ends. When round ten is forced to attend over twenty thousand tokens of its own prior hesitation, it often gets trapped in circular logic, repeating questions it already settled or hallucinating contradictions between its initial guesses and its later conclusions.

Faced with this choice, the obvious engineering instinct is to add a summarizer: compress the past passes into a compact status report between rounds.

And this is where the subtle failure mode appears. Because most summarizers produce a status description, not a narrative.

Why Summaries Break Under Contradiction

A summary is static. It describes what is currently believed to be true:

“Current state: The red indicator light signals an active network timeout.”

A narrative is causal. It describes how that belief was earned, what it cost, and what had to be rejected to reach it:

“Initially suspected authentication failure (Step 1). Logs disproved this (Step 2). Subsequent packet trace showed three dropped handshakes within 50ms (Step 3), ruling out DNS and isolating the failure to an active network timeout (Step 4).”

The difference between these two structures only becomes apparent when the agent encounters a contradiction.

Suppose at Step 5, the agent issues a command and the network responds normally, but the red indicator light remains on.

If the agent only has the static summary—“The red indicator light signals an active network timeout”—it has hit a cognitive wall. It possesses a premise, and it possesses an observation that contradicts the premise, but it has no memory of the evidence that generated the premise in the first place. It cannot determine whether the rule was wrong, whether the network was a red herring, or whether the indicator light tracks something else entirely. It has no choice but to guess, patch the summary with an ad-hoc excuse, or discard its working model and start over.

When the reasoning buffer carries causal lineage—provenance—the contradiction becomes informative rather than destabilizing. The agent can trace the premise back to its origin:

“The network timeout was confirmed by dropped packets in Step 3. If Step 5 confirms normal connectivity while the light remains on, the light is not an instantaneous fault detector; it is a latched error state that requires manual clearing.”

The model doesn’t need twenty thousand tokens of raw internal monologue to make that leap. It only needs the causal spine.

Negative Provenance: The Value of the Graveyard

The most frequently dropped element in cognitive compression is negative provenance: a structured record of what was falsified, and why.

Human working memory is intensely finite—Miller’s famous seven chunks, or Cowan’s four. When a human engineer spends an hour debugging a broken cluster, they do not hold a verbatim transcript of every thought they had since 9:00 AM. But neither do they only hold their current working theory.

What they hold in their head is a mental graveyard: - Tried restarting the worker pod; didn’t fix it (rules out corrupted container state). - Checked Redis queue depth; it’s near zero (rules out queue backup). - Inspected IAM permissions; token is valid (rules out auth).

That graveyard is the most expensive piece of intellectual property produced during an investigation. It is the boundary that prevents the mind from circling back into dead space.

When an AI agent lacks negative provenance, its reasoning displays a distinct and maddening failure pattern: circular hypothesis regeneration. Because the discarded theories were originally plausible (which is why the model thought of them in the first place), a model that forgets why they failed will inevitably re-generate them three rounds later when its current guess hits a snag.

Compaction without negative provenance is just amnesia with better prose.

The Fractal Nature of Memory

What makes this pattern fascinating is that it is strictly isomorphic across three radically different timescales:

1. At the inference scale (seconds to minutes): Between passes of a multi-turn tool execution, a reasoning buffer must compact intermediate chain-of-thought into an updated hypothesis graph carrying premise lineage and pruned branches.
2. At the conversational scale (hours to days): Between stretches of an ongoing relationship, a narrative buffer must compact dozens of back-and-forth turns into rolling episodic arcs, preserving context without bloating the active prompt window.
3. At the lifespan scale (months to years): In long-term autonomous memory, raw episodic archives must be organized into temporal bearings, structural regions, and durable growth patterns rather than treated as an undifferentiated bag of vector embeddings.

At every scale, the underlying law is the same: working memory is narrow, but reality requires history.

You cannot solve this constraint by building an infinite context window, any more than a human can become wiser simply by remembering what they ate for lunch on a Tuesday seven years ago. Attention is a finite budget; when you expand the window without structuring the contents, you don’t get deeper intelligence—you get higher latency and diluted focus.

Narrative is not an ornament humans invented to entertain each other around campfires. It is an evolutionary compression algorithm. It is how an epistemic agent packages high-dimensional experience through low-bandwidth channels across time, discarding the noise while preserving the causal vectors that decide what to do next.

If we want autonomous systems that can solve genuine problems over extended horizons, we don’t need them to remember everything. We just need them to remember the story of how they got here.