Skip to content

Glossary · Agent handoff

What is an agent handoff?

An agent handoff is passing a job from one AI agent or session to another, along with what was tried and what is left. A good handoff means the next agent doesn't start from scratch or repeat the dead ends. Without notes, each new session begins knowing nothing about what came before.

In practice

A coding agent runs out of context halfway through a migration. Another session picks up the branch. If the first left nothing, the second re-reads files, retries the approach that failed, and may undo working code. If the first left a note, saying what it changed, what broke and what is left, the second starts where it stopped.

A handoff can go agent to agent, session to session, or agent to person. It is not the same as running agents in parallel, and it isn't a summary of the whole chat. It is the few facts the next worker needs.

Anthropic's engineering team describes the problem for long-running work: each new session starts with no memory of what came before, so agents leave progress notes and a git history for the next one to read.

A handoff note template

  • Job: the one-line goal and where the spec lives.
  • Done: what is finished and checked, with a branch or commit.
  • Tried: what you attempted that didn't work, and the error or reason.
  • Left: what remains, in order.
  • Watch for: anything surprising, such as a flaky test or a file someone else is editing.

Keep it under ten lines. The next agent reads it first, so it must fit alongside the work.

Common mistakes

  • Handing over the whole chat. The next agent gets the noise and misses the decision.
  • Leaving out what failed. Dead ends are the most useful part, because they stop the repeat.
  • Two agents holding the same job at once. Hand over, don't share.

Why it matters for product builders

Handoffs fail quietly. The next agent looks capable, and it repeats an approach that already failed or overwrites work that was fine. You find out when the build breaks.

If you run two or more agents, you are the handoff by default. You carry what happened from one chat to the next. A written note moves that load off you.

What changes in AI-first products

This term is new because of agents. People have always handed off work, but a person remembers the project. An agent's context ends with the session, so the note is all that carries over.

What a note should hold hasn't changed from a human handoff: what the job was, what was done, what failed and why, and what is left. In Annsa, one agent holds each job, and if it gets stuck it hands over with notes on what it tried.

See how Annsa does it: Hand off and ship →

Questions people ask.

Q1

Why do coding agents need handoffs?

A session's context ends when the session does. A new session starts without the history, so the work only carries on if the previous one left notes and a clear state in the code.
Q2

What should an agent handoff include?

The goal, what is done and checked, what was tried and failed, what is left, and anything to watch for. Short and ordered beats long.
Q3

Is an agent handoff the same as an escalation to a person?

They are related. An escalation hands the job to a person because a decision is needed. A handoff to another agent passes the job on when the first is stuck or out of room. Both carry notes.

Sources

  1. Each session starts with no memory, so agents leave progress notes and git history for the next.

  2. Anthropic EngineeringBuilding effective agents

    Agents work independently and can pause for human feedback at checkpoints or blockers.

Last reviewed 2026-10-21

Put it to work with your agents.

Try Annsa