How does an AI agent hand off unfinished work?
By Soumen Sarkar · October 2026
Short answer: An AI agent hands off unfinished work by leaving a short note with the work when it stops: what's done, what's left, the next step, the open questions and the traps. Whoever continues, person or agent, starts from that note instead of from the agent's transcript.
What goes into a good handoff?
A handoff is what unfinished work carries for whoever continues it. It answers five things, in this order:
- Done: what is finished and can be relied on.
- Unfinished: what was started and isn't complete.
- Next step: the single concrete thing to do first.
- Open questions: what the agent assumed or couldn't settle.
- Traps: what looks right but isn't, and what was tried and dropped.
Keep it short. A good handoff fits on one screen. The person who picks it up should be working within a minute, not reading for ten.
Why can't the next person just read the session?
Because a session is a conversation, not a summary. It holds every false start, every file the agent opened and every idea it dropped. The one line that matters, "the retry count is hardcoded on purpose", sits somewhere in the middle of it.
At agent pace, sessions stop all the time: the context fills up, a developer closes a laptop, a task runs out of budget. If each stop leaves only a transcript, every pick-up starts with an hour of archaeology. A handoff turns that hour into a minute.
What does a handoff look like in practice?
Say an agent is batching notification emails into a daily digest in Notifications · lib/notifications, and the session ends halfway through. Its handoff reads:
- Done: digest builder groups events per user per day; tests pass.
- Unfinished: the scheduler isn't wired up; digests are built but never sent.
- Next step: register the digest job in the scheduler at 07:00 in each user's timezone.
- Open questions: assumed users with no timezone set get UTC. Not confirmed.
- Traps: don't reuse the instant-send queue; it retries on failure and would send a digest twice.
Anyone can continue from that. Nobody has to message the person who started it, and nobody repeats the dead end with the instant-send queue.
When should an agent write it?
Every time it stops, not only when it finishes. The moments that matter most are the unplanned ones: a context window compacting, a session timing out, a developer switching to something urgent. Those are exactly the moments nobody remembers to write anything.
So make it automatic or make it an instruction. In agent instructions, a line like "before you stop for any reason, write a handoff with done, unfinished, next step, open questions and traps" works with any agent. The handoff template gives the shape.
How does Campfyrr handle handoffs?
In Claude Code, Campfyrr writes the handoff from the session when it stops, compacts or ends, so nobody has to remember. The transcript itself isn't kept, only the handoff. It shows in the project's Activity feed as work paused partway, with its next step, and in the next session brief of whoever it's meant for, at the top under "Pick up where it was left". Agents in Codex or Cursor call hand_off themselves, following the server's instructions.
The measure that matters is pick-up time: how long unfinished work sits before someone continues it. Good handoffs make it short, because nobody has to come and ask.
Words used here
- Handoff: A handoff is what unfinished work carries for whoever continues it: what's done, what's left, the next step, and what to watch out for.
- Assumption: An assumption is the best available answer to an unknown, stated and acted on, kept visible so anyone can correct it.
- Pick-up time: Pick-up time is how long a handoff waits between being left and someone picking it up to continue the work.
The principle behind this: Let the work speak: Our work explains itself, so nobody ever has to come and ask us.
Move as one at agent speed. Nobody waits. Add Campfyrr to Claude: it briefs every agent before it touches the code, keeps assumptions and handoffs where the team can see them, and never takes your code (what it keeps).