The context window is not a system of record

Kill every agent session you have running right now. What does your system still know?

Who owns each piece of work, what state it is in, what the last actor finished, and what they warned about: if those answers lived in conversations, they are gone. A context window is a working buffer with a hard capacity. Every serious agent runtime truncates or summarizes older content as a session grows, and sessions simply end.

Databases named the missing property decades ago: durability. An acknowledged fact must survive a crash, so write-ahead logs persist every change to stable storage before it counts as real. SQLite’s write-ahead logging documentation puts it plainly: the log on disk is the truth, and memory is always reconstructible from it. A transcript inverts this. The most important operational facts sit in the most volatile medium available.

What exactly disappears?

Consider what a compaction or a kill takes with it. Ownership goes first: the agent “knew” it owned a task, nothing outside the process knows, so a peer duplicates the work or waits on a ghost. Status goes with it. The order of events, what was tried and why it was abandoned, is precisely the material summarization discards first. The traps, the half-finished migration, the reason the obvious approach failed, get rediscovered at full price by the next actor.

A larger window does not fix this. Ordering and shared knowledge between processes are properties of a system rather than of any one participant’s memory, the core observation of Lamport’s Time, Clocks, and the Ordering of Events in a Distributed System. Agreement between actors has to live in a shared, durable medium with its own ordering.

A handoff is a write

The first requirement: leaving a task must itself be a durable operation. Axial’s release requires at least one of three handoff fields (what is done, what remains, what will trap the next actor), because a release without a note would transfer ownership without transferring knowledge.

$ axial issue release PLAT-1 \
    --done "store adapter + migration 0004" \
    --remaining "cli flag parsing and golden" \
    --gotchas "cycle check is O(n); fine for now"
released PLAT-1 by codex

Three single lines, written while the departing actor still knows everything, persisted on the task and in the append-only activity log. The transcript that produced the work can now vanish without losing anything a successor needs.

A lapsed lease and a release are different operations: the lease returns work from a dead agent with no note, the release from a live agent with one. Having only the first recovers ownership without recovering context.

Re-orientation is one read

The mirror requirement: an arriving actor, fresh or resumed after compaction, must rebuild its situation from durable state alone, cheaply. Axial’s context packet does it in one read:

$ axial context PLAT-1
id: PLAT-1
title: Fix vector search
status: in_progress
assignee: codex
lease: 2026-07-12T02:00:00Z
handoff_by: fable
handoff_at: 2026-07-11T18:00:00Z
handoff_done: store adapter + migration 0004
handoff_remaining: cli flag parsing and golden
handoff_gotchas: cycle check is O(n); fine for now
...

The packet leads with ownership and the latest handoff and ends with the unbounded description; it is designed for onboarding rather than browsing.

What changed while I was gone?

One task’s packet says nothing about the rest of the world. The second read is delta sync: persist a small cursor, and after any interruption ask only for what changed since:

$ axial changes --since YXhjMTo0
count: 3 changes
DOCS-1 [todo]: Write the guide
PLAT-1 [in_progress] p:high @codex #backend: Fix vector search
PLAT-2 [todo] p:low: Write docs
cursor: YXhjMTo3

The whole scheme is the database recovery pattern applied to coordination:

durable log ──[seq 4]──[seq 5]──[seq 6]──[seq 7]──▶
                 ▲                          ▲
          cursor saved                replay from here
          before the interruption     after the restart

The cursor is opaque; the caller stores it and hands it back. It rides on the same authority-assigned sequence that orders the activity log, so “since” has one meaning for every reader. Even the empty case is a positive, resumable fact: 0 changes for since:YXhjMTo3 with the same cursor.

A compacted agent is just a process recovering from a checkpoint.

The implication

Run the kill test on your own human-and-agent workflow. If the answers are writes (claims, status changes, handoffs, an ordered log), sessions become what they should have been all along: disposable compute over durable state. The context window is where an agent thinks. The work has to live somewhere that survives it.

Kill the session; the work should still be there.