Handoff debt, and the files that pay it down

A 2026 paper measured what it costs a coding agent to take over another's unfinished work. Here is what it found, and how Carol's handoffs and planning files are built around it.

Cover for Handoff debt, and the files that pay it down

Agent sessions end before the work does. The context window fills, a run is left going overnight, or a question waits on a person. Whoever picks the work up next, another agent or the same one in a fresh session, starts by finding out where things stand. That rediscovery costs something, and a 2026 paper put a number on it.

What the paper measured

The paper:

Handoff Debt: The Rediscovery Cost When Coding Agents Take Over Interrupted Tasks · Dipesh KC and Anjila Budathoki · arXiv 2606.02875 · version 2, August 2026

It interrupts a coding agent at fixed points, freezes the repository, and hands the task to a successor agent. The successor gets one of four views of the work so far:

  1. the repository only;
  2. the raw trace of the first agent's session;
  3. summary notes;
  4. structured notes.
The paper's four handoff views, from the repository alone to structured notesThe paper's four handoff views, from the repository alone to structured notes
The paper's four handoff views, from the repository alone to structured notes

The scale: 75 source tasks, 181 handoff points, 724 takeover runs for each of three successor models.

NumberWhat it comparesSource
42–63%fewer cumulative prompt tokens, handoffs that carry context against the repository onlythe paper's abstract
20–59%fewer median agent events, same comparisonthe paper's abstract
smaller, model-dependentthe effect on how often the task was solvedthe paper's abstract

The paper calls the cost of resuming opaque work handoff debt, and its conclusion is about evaluation: report how costly a task is for another agent to resume, not only whether it was solved.

What it doesn't say

It measured handoffs. It didn't measure acceptance checks, planning files in general, or Carol, and it found the effect on solving the task smaller than the effect on cost, and different from model to model. So the claim here is the narrow one: a successor that gets the context spends far less finding its place.

A handoff in Carol

Carol's workflow writes one file whenever a session stops before the initiative does: docs/<initiative>/handoff.md. It is a structured note in the paper's sense, with a fixed shape:

  • frontmatter with five keys: the initiative, when the session stopped, the station, the phase, and who wrote it;
  • seven sections in order: Stopped at, Done this session, In flight, Waiting on a human, Next action, Uncommitted, Watch out.

carol handoff check validates that shape: the five keys, a station that is one of the six the workflow knows, the seven sections in order, and no section left empty without saying None.. carol status says whether the handoff is fresh or stale, and what has changed since the session stopped.

The handoff is not the only context. It points into the planning files the successor reads next: scope.md with the phases table and the decisions so far, the design record, the PRD and its trail. They are the source of truth, and the handoff only says where in them to start.

One takeover, from this site

The session that wrote this post began with three words: "start from handoff". The handoff it read, from the end of the previous session, said:

  • five of six phases were done, and the sixth, these posts, was waiting on a design interview;
  • the next action was that interview, and it was the user's to start;
  • two things to re-check before acting: that carol status showed the phase as planned with no open tickets, and that the tree was clean and level with GitHub.

The session ran those two checks, both held, and its next step was the interview's first question. Nothing was rediscovered by reading the repository.

The Watch out section did more. One entry said to commit with an explicit path list while a run's work is uncommitted, because a run leaves deletions staged and a plain git commit ships them. That trap had cost the site four minutes of broken figures one session earlier. The next session read it and avoided it before it came up.

Why the shape matters

A handoff written freehand drifts. One session leaves out what is uncommitted, another forgets the open question, and the successor finds out the expensive way. A fixed shape with a check turns "write a good note" into something a command can fail. A handoff that is wrong still passes the check, so every handoff in this repository also names what to re-check before acting, and the successor treats it as a hint, not as fact.

This repository has 164 commits since its first, on 8 October 2026. 47 of them change a handoff file.

By the numbers

NumberWhat it countsSource
42–63%fewer prompt tokens with a context-bearing handoffarXiv 2606.02875
20–59%fewer median agent events, same comparisonarXiv 2606.02875
7 sections, 5 keysthe shape carol handoff check validatesCarol 0.1.21
47 of 164commits in this repository that change a handoff file, since 8 October 2026git log, 3 November 2026