DEEP DIVE SERIES · #13

Zero-Loss Context Resets and Agentic State Handover: Maintaining Long-Running Task Coherence

Luca Viscomi

· Published Sep 21, 2026 · Updated Sep 24, 2026 · 5 min read

Autonomous AI agents excel at sprints, but routinely fail at marathons.

If you assign an agent a complex, end-to-end task—such as “Migrate this full-stack application from Webpack to Vite, update all test mocks, fix all TypeScript lints, and ensure CI passes”—the task will rarely conclude in 10 turns. It will take 40, 60, or 100 turns.

By turn 35, two catastrophic realities collide:

1. Context Window Saturation: The conversation trajectory approaches the physical context limit (128k or 200k tokens).
2. Attention Dilution & Latency: Generating a single response takes 45 seconds and costs $0.60, while the model’s accuracy on subtle instructions drops off a cliff (a phenomenon well-documented in attention retrieval studies like Lost in the Middle by Liu et al.).

Teams typically attempt two fixes: either they blindly truncate earlier messages (losing the original user constraints), or they rely on automated model summarization (which hallucinates or omits critical architectural nuances).

The production solution is Zero-Loss Context Resets via the State Handover Protocol.

1. The Anatomy of State Handover

A State Handover is the agentic equivalent of an OS process checkpoint and context switch:

[ Active Session Reaches 20 Turns or 70% Context Capacity ]
                             │
                             ▼
              [ Phase 1: State Crystallization ]
   Agent is mandated to execute `compile_state_handover()`
   Extracts: Active Goal, Completed Steps, File Touched,
   Unresolved Bugs, and Pending Actions into `STATE.md`.
                             │
                             ▼
              [ Phase 2: Memory Eviction (Wipe) ]
   Harness archives the 100,000-token historical trajectory
   to durable cold storage (.jsonl disk archive).
                             │
                             ▼
              [ Phase 3: Zero-Loss Re-Anchoring ]
   Harness spawns a fresh session (Turn 0) containing ONLY:
   - System Prompt & Tool Schemas
   - Original User Goal
   - The Crystallized `STATE.md` Checkpoint
                             │
                             ▼
           [ Agent Resumes Execution with 95% Clean Context ]

Instead of drowning in 90,000 tokens of dead tool outputs and obsolete compiler errors, the agent resumes work with only 3,000 tokens of high-signal, distilled operational context.

2. The Checkpoint Schema: What Must Be Preserved?

A successful State Handover does not summarize the conversation into a vague narrative paragraph. It crystallizes state into a Structured Engineering Checkpoint:

# AGENTIC STATE HANDOVER CHECKPOINT
**Session ID**: `sess_98234` -> `sess_98235`
**Timestamp**: 2026-09-22T23:55:00Z
**Checkpoint Index**: 2

## 1. High-Level Mandate
Migrate build pipeline from Webpack 5 to Vite 5 and verify TypeScript builds.

## 2. Verified Completed Milestones
- [x] Installed `vite`, `@vitejs/plugin-react`, and removed `webpack.config.js`.
- [x] Configured `vite.config.ts` with path aliases matching `tsconfig.json`.
- [x] Converted `index.html` root template to Vite entry format (`<script type="module" src="/src/main.tsx">`).

## 3. Active Working Set (Files Modified)
- `package.json` (Vite dependencies added, scripts updated)
- `vite.config.ts` (Created)
- `src/main.tsx` (Entry point cleaned)

## 4. Current Blocker / Failing Assertion
- `npm run build` fails with:
  `[vite:esbuild] Unexpected token (Line 142 in src/legacy/polyfills.ts)`
- Cause: Legacy AMD `require()` syntax detected.

## 5. Immediate Next Step (Turn 0 of New Session)
Refactor `src/legacy/polyfills.ts` line 142 to use standard ES dynamic `import()` or exclude from Vite bundle.

When the newly initialized agent begins Turn 0, it does not need to guess what happened on Turn 14. It immediately reads Section 5 and gets to work on the exact blocker.

3. Implementing the State Handover Protocol in TypeScript

Below is the state orchestration harness that detects context pressure, triggers crystallization, and seamlessly resets session state:

import * as fs from 'fs';
import * as path from 'path';

export interface HandoverState {
  originalMandate: string;
  completedTasks: string[];
  activeWorkingFiles: string[];
  currentBlocker: string;
  nextImmediateAction: string;
}

export class StateHandoverManager {
  private turnCount: number = 0;
  private maxTurnsPerEpoch: number = 20;
  private checkpointDir: string;

  constructor(checkpointDir: string) {
    this.checkpointDir = checkpointDir;
    if (!fs.existsSync(checkpointDir)) {
      fs.mkdirSync(checkpointDir, { recursive: true });
    }
  }

  public shouldTriggerHandover(currentTurnTokens: number): boolean {
    this.turnCount++;
    // Trigger if turn limit reached OR context exceeds 70% of 128k (89,600 tokens)
    return this.turnCount >= this.maxTurnsPerEpoch || currentTurnTokens > 89600;
  }

  public persistCheckpoint(state: HandoverState, epochIndex: number): string {
    const fileName = `checkpoint_epoch_${epochIndex}.json`;
    const filePath = path.join(this.checkpointDir, fileName);
    fs.writeFileSync(filePath, JSON.stringify(state, null, 2), 'utf-8');

    // Reset local epoch turn counter
    this.turnCount = 0;
    return filePath;
  }

  public buildResumePrompt(state: HandoverState): string {
    return `
<RESUMED_SESSION_STATE>
You are continuing an ongoing autonomous task. Your previous session completed an operational checkpoint.

ORIGINAL MANDATE: ${state.originalMandate}

COMPLETED MILESTONES:
${state.completedTasks.map(t => `- [x] ${t}`).join('\n')}

ACTIVE WORKING FILES:
${state.activeWorkingFiles.map(f => `- ${f}`).join('\n')}

CURRENT BLOCKER:
${state.currentBlocker}

YOUR IMMEDIATE OBJECTIVE:
${state.nextImmediateAction}
</RESUMED_SESSION_STATE>
`.trim();
  }
}

4. Quantitative Results: Marathon Agent Benchmarks

We evaluated the State Handover Protocol against standard monolithic sessions across 10 multi-hour refactoring tasks (40–80 turns):

5. Summary: The Golden Law of Agentic Persistence

Never ask a model to remember what you can crystallize to disk.

Context windows are computational working memory, not long-term storage drives. By engineering automated State Handover checkpoints into your agent harness, you transform brittle, forgetful loops into unstoppable, enterprise-grade autonomous engineering engines.