What it is
A handoff is the moment a piece of work changes hands. One worker stops, another starts, and everything the first one knew has to travel across the gap, or it's lost. In AI, the word covers three situations that look different on the surface but fail in exactly the same way.
Agent to agent. An agent is an AI system that works towards a goal by taking actions, not just by answering. In a system with several agents, one of them often decides that another is better suited to the job and passes the whole conversation across. A front-desk agent works out that you want a refund and hands you to the refunds agent, which then talks to you directly. The first agent steps back. That's what separates a handoff from a subagent, where a lead agent sends a helper off for a narrow job and keeps control of the conversation throughout.
AI to human. A chatbot or agent reaches the edge of what it should handle and passes the case to a person: a customer-support bot escalating a complaint, a coding agent asking a developer to approve a risky change, a writing assistant handing a draft back to its author. The person needs to know what happened without scrolling through forty messages.
Chat to chat. This one is the most common and the least noticed. You've been working with a chatbot for two hours, the conversation is getting long and muddled, and you start a fresh chat to carry on. The new chat knows nothing. Whatever you paste into it is the handoff. Coding agents do the same thing when a job runs across several sessions: each session starts cold and has to be told where things stand.
In all three, the thing being passed isn't only the task. It's the state of the task: what the goal is, what has been done, what hasn't, what was decided and why, what's still unclear, and where the materials are. A handoff that passes the task without the state forces the next worker to guess, and guesses are where errors come from.
Hospitals learned this long before AI existed. Every day, nurses and doctors finish their shifts and hand their patients over to the next team. Medicine calls this a handover or a sign-out, and it has studied it for decades, because it's one of the riskiest moments in patient care. The patient hasn't changed, but the person who knows them best has just gone home. The structures that hospitals built to make handovers safe turn out to transfer almost directly to AI, and this article leans on them.
Handing back is part of the same idea. When the specialist agent has finished, or the human has made their decision, or the fresh chat has done its piece of work, the job often comes back to where it started. That return trip is also a handoff, and it needs the same care. "Done" isn't a handoff note. "Done: refund issued for order 4471, customer told it takes five working days, nothing else outstanding" is.
Why it matters
Handoffs are where information falls out. Every transfer squeezes a long history into something shorter. The first worker knows why a decision was made, which options were tried and rejected, and which detail the customer mentioned in passing that turned out to matter. Unless that's written down or passed along, the next worker doesn't have it. In AI systems this is literal: a model only knows what's in its context window, the working space of text it can see at one time. If it isn't in the window, it doesn't exist.
Medicine has measured the cost. In September 2017, The Joint Commission, the body that accredits most US hospitals, published an alert on inadequate hand-off communication. It pointed to a 2016 estimate, from the malpractice research firm CRICO Strategies, that communication failures in US hospitals and medical practices were at least partly responsible for 30 percent of malpractice claims, resulting in 1,744 deaths and $1.7 billion in malpractice costs over five years. The alert also cited an estimate that a typical teaching hospital may see more than 4,000 handoffs a day. A risky moment that happens thousands of times a day is worth getting right.
AI makes handoffs more frequent, not less. A single chatbot conversation has no handoffs. A multi-agent system, where several AI agents with different roles work together, has one at every boundary between roles. A support system that combines a bot with human staff has one every time a customer asks for a person. And anyone who uses AI for long projects hands off every time they start a new chat. The more work AI does, the more transfers there are, and each one is a chance to lose something.
The failures are quiet. A lost detail rarely causes an error message. The next agent simply carries on, confidently, with a slightly wrong picture. It redoes work that was already done, reverses a decision it didn't know had been made, or promises a customer something the previous agent had already ruled out. Because the output still looks fluent, nobody notices until the consequences arrive.
People judge the whole system by the handoff. Customers forgive a bot that can't solve their problem. They don't forgive having to explain everything again to the human who takes over, or never reaching a human at all. For a business, the handoff to a person is often the moment trust is won or lost.
Good handoffs are cheap. The encouraging part of the hospital research is that a better handoff doesn't need new technology, just a consistent structure and the habit of using it. The same is true with AI. A short, well-organised note, written at the right moment, fixes most of what goes wrong.
Real-world examples
I-PASS: a structured handover cuts hospital errors (2014)
In the early 2010s, a group of pediatricians led by Amy Starmer and Christopher Landrigan at Boston Children's Hospital developed I-PASS, a structured way for resident doctors (doctors in training) to hand over patients at shift change. The name is a memory aid for the five parts of every handover: Illness severity (how sick is this patient?), Patient summary (what's going on and what's the plan?), Action list (what does the next person need to do?), Situation awareness and contingency planning (what might happen, and what should you do if it does?), and Synthesis by receiver (the person taking over repeats back what they heard and asks questions).
The programme was more than the letters. It combined the memory aid with training in handover and communication, a written handover document, observation and feedback from senior doctors, and a campaign to keep it going. The team tested it in nine teaching hospitals in the United States and Canada and published the results in the New England Journal of Medicine on 6 November 2014.
Across 10,740 patient admissions, the rate of medical errors fell by 23 percent after the programme was introduced, from 24.5 to 18.8 per 100 admissions. Preventable adverse events, meaning errors that actually harmed patients, fell by 30 percent, from 4.7 to 3.3 per 100 admissions. The researchers also timed the handovers, and the spoken part took about the same time before and after: 2.4 minutes per patient before, 2.5 after. The study compared periods before and after the change, rather than randomly assigning hospitals, so it shows an association rather than strict proof of cause. The Joint Commission's 2017 alert cited it as an example of what a good handoff programme can achieve, and recommended standardised content and tools for every handoff.
Three lessons carry straight over to AI. The structure is small enough to remember. It includes a contingency plan, not just a status report. And it ends with the receiver saying back what they understood, which catches misunderstandings before the sender has gone.
OpenAI makes "handoffs" a building block for agents (2024 to 2025)
In October 2024, OpenAI published Swarm, a small open-source framework for coordinating several AI agents. OpenAI labelled it experimental and educational, not a product for real-world use. What made it influential was its simplicity: it had two core ideas, agents and handoffs. An agent was a set of instructions plus the tools it could use. A handoff was one agent passing an active conversation to another. OpenAI's accompanying cookbook guide compared it to being transferred to someone else on a phone call, except that the new agent can see everything said so far.
In March 2025, OpenAI released the Agents SDK, an open-source toolkit for developers building agents, which it described as inspired by Swarm and which the Swarm project now points to as its replacement. At the time of writing, its documentation treats handoffs as a core feature. To the model, each possible handoff looks like a tool it can choose to use, with a name like "transfer to refund agent". By default, the new agent takes over and sees the entire previous conversation. Developers can add an input filter, a small piece of code that trims what the next agent receives, for example removing the record of earlier tool calls. The documentation also provides recommended wording to add to agents' instructions so that they understand how handoffs work.
That design shows the central trade-off in any handoff. Passing everything is safe in one way, since nothing is dropped, but it hands the next agent a long, noisy history in which the important part may be buried. Passing a trimmed version is cleaner but risks cutting the one detail that mattered. Either way, somebody has to decide what the next worker needs, which is exactly the question a hospital handover answers. Tools and features in this area change often, so check the current documentation rather than relying on this summary. The Subagents article covers the SDK's other pattern, "agents as tools", where a manager agent keeps control.
The "doom loop": when a chatbot can't hand over (June 2023)
In June 2023, the US Consumer Financial Protection Bureau (CFPB), the federal agency that oversees banks and lenders on behalf of consumers, published a report on chatbots in consumer finance. It found that all ten of the largest US commercial banks had deployed chatbots in their customer service, and estimated that about 37 percent of the US population had interacted with a bank's chatbot in 2022.
The report's most memorable finding was about missing handoffs. It described customers caught in what it called "doom loops": continuous loops of repetitive, unhelpful answers with no way through to a human customer service representative. The CFPB said these loops often happen when a customer's problem falls outside what the chatbot can handle. It quoted complaints from customers who said they couldn't reach a person at all, and it raised a particular worry about disputes: a chatbot may not recognise that a customer is disputing a charge unless they use the right words, so a problem the law requires the bank to investigate can simply go nowhere. The report concluded that when an AI fails to understand a request, it isn't suitable as the primary customer service channel.
A doom loop is a handoff failure in its purest form. The bot has reached the edge of what it can do, and there's nowhere to pass the case. For anyone building a support bot, the lesson is that the route to a person is not an optional extra. It's part of the design, and it needs testing like everything else. The Customer Support article covers the wider picture of AI in support.
Anthropic's agents leave notes for the next shift (November 2025)
On 26 November 2025, Anthropic published an engineering post about agents that work on a single project across many sessions, such as building a web application over hours or days. The problem it described is the chat-to-chat handoff at scale. Each new session starts with no memory of the last one. The post compared it to a software project staffed by engineers working in shifts, where each new engineer arrives with no memory of the previous shift.
Anthropic described two failure patterns. Agents tried to do too much in one go and ran out of room partway through, leaving work half-finished and undocumented for the next session. And later sessions looked at the progress so far and wrongly declared the whole job done.
The fix was a set of deliberate handoff habits. A first session sets up the project: a list of every feature needed, all initially marked as not yet working; a progress file; and a script to start the application. Every later session begins the same way: read the progress file and the recent history of changes, check that the basic application still works, then pick one unfinished feature and work on it. Before finishing, the agent records what it did in the progress file and saves its changes with a descriptive note in the project's version history, leaving things in a clean state for whoever comes next. In other words, the agent writes itself a shift handover, and reads the last one before it starts.
An everyday scenario: the grant application that changed hands
This is an illustration, not a documented case. A small arts charity is preparing a grant application. Priya, the volunteer coordinator, has spent two evenings with a chatbot drafting it. On Friday she hands the job to her colleague Tom, who will finish it over the weekend in his own chatbot account.
Her first handoff is a message: "Draft's in the shared folder, just needs tidying." Tom opens it, sees a section on volunteer numbers that looks thin, and asks his chatbot to expand it with the charity's 2023 figures. What he doesn't know is that Priya had deliberately cut that section, because the funder's guidance says to report only the last twelve months, and that she'd already confirmed the budget total with the treasurer, which Tom then "corrects" from an older spreadsheet.
The second time round, Priya writes a proper handoff: the goal and deadline, which sections are finished and must not change, the two decisions she'd made and why, the one open question (whether to include a letter of support), and where each file lives. Tom's first message to his chatbot is that note. The weekend goes smoothly, and on Monday Tom hands it back the same way: what he changed, what he didn't touch, and what still needs Priya's sign-off.
Try it yourself
This exercise takes about 30 minutes and works with any chatbot. You'll write a handoff note for a real piece of unfinished work, then test it by giving it to a fresh chat and seeing whether it knows what to do next. The template borrows the spirit of I-PASS, adapted for everyday work rather than patient care.
- Pick something unfinished. Choose a real task you're partway through: a report, a newsletter, a product launch, a chapter, a spreadsheet clean-up. It works best if it has a history, meaning decisions you've made and options you've rejected. If you've been working on it in a chatbot, have that conversation open.
- Write the note yourself first. Fill in this template by hand, before asking any AI to help. The point is to notice what you know that isn't written down anywhere. Keep each line short.
HANDOFF NOTE
Status: [one line: on track / stuck / urgent, and the deadline]
Goal: [what "finished" looks like, in one or two sentences]
Done: [what is complete and should not be redone or changed]
Not done: [what remains, in the order it should be tackled]
Decisions made, and why: [each choice that someone might
otherwise reverse, with the reason]
Ruled out: [options already tried or rejected, so they are
not suggested again]
Open questions: [anything unresolved, and who can answer it]
If this happens, do that: [likely problems and what to do]
Files and places: [where each document, link or login lives;
never paste passwords]
Next step: [the single first thing the receiver should do]
- Fill the gaps from the old conversation (optional). If the work lives in a long chat, you can ask that chat to check your note against the history. Paste your note, then this:
Here is a handoff note I've written for this work. Compare it
with our whole conversation. List anything important that's
missing: decisions, rejected options, constraints, or open
questions. Quote the part of our conversation each one comes
from. Don't rewrite my note; just list the gaps.
Asking for quotes makes it harder for the model to invent gaps that aren't there. Add anything genuine to your note.
- Test it in a fresh chat. Open a brand-new chat, so it can't see any earlier conversation, and paste your note followed by this:
You are taking over this piece of work from a colleague. Using
only the handoff note above:
1. Say back, in your own words, what the goal is and where
things stand.
2. Tell me exactly what you would do first, and why.
3. List every question you'd need answered before you could
finish the job.
4. Name anything in the note that is ambiguous or that you
might accidentally undo.
Do not start the work yet.
Step 1 of that prompt is the "synthesis by receiver" part of I-PASS. It's the check that catches misunderstandings.
- Grade the read-back. Compare the fresh chat's answer with what you know. Did it get the goal right? Is its first step the one you would have taken? Did it propose anything you'd already ruled out? Every question it asks in point 3 is a gap in your note, and every item in point 4 is a place where the next worker could go wrong.
- Fix the note and test again. Add what was missing, then paste the revised note into another new chat with the same prompt. Stop when the read-back matches what you'd tell a trusted colleague. Most people find that the second version is only a few lines longer but much clearer.
- Practise handing back. When the work (or the next piece of it) is done, write a short return note using just four lines: what changed, what was left alone, what's still open, and what needs a decision from the original owner. Paste it into the original chat or send it to whoever handed the work over.
- Keep the template. Save your final template somewhere you can find it. Use it whenever you start a fresh chat on a long project, hand work to a colleague, or set up a bot that passes cases to a person. The sections won't change much; what changes is how quickly you can fill them in.
Common mistakes and misunderstandings
Passing the task without the state. "Can you finish the newsletter?" is a task. The state is everything around it: who it's for, what's already been cut, which subject line was tested and failed. The next worker, human or AI, can only work from what's handed over. A task without state is an invitation to guess.
Leaving out the "why". The most dangerous gap in a handoff note is a decision without its reason. The next worker sees something that looks odd, has no idea it was deliberate, and "fixes" it. Every decision that someone might plausibly reverse deserves a few words of explanation.
Forgetting what was ruled out. If you don't record the options you rejected, a fresh chat will cheerfully suggest them again, and you'll waste time re-arguing old ground. "We tried a discount code; it attracted bargain hunters who didn't come back" saves an hour.
Dumping the whole history instead of summarising. Pasting an entire conversation into a new chat feels safe, but it passes along every abandoned idea and outdated instruction too, and the important part can get lost in the middle. A good handoff is a selection, not a transcript. The Context Engineering article explains why a clean, well-chosen context usually beats a long one.
Letting the AI write the handoff unchecked. Chatbots are good at drafting summaries, and asking for one is a useful start. But a model can drop details, blend two decisions into one, or state as settled something that was still open. It can even invent a decision that was never made, a failure known as hallucination. Always read an AI-written handoff against what you know before relying on it.
No way to reach a person. For customer-facing bots, the commonest handoff failure is having no handoff at all, the CFPB's "doom loop". A route to a human should work at any point, from the first message, and it should pass the conversation along so the customer doesn't have to start again.
Handing over without handing back. A task that goes out to a specialist, a colleague or a new chat has to come back in a form the original owner can use. "Done" is not enough. Say what changed, what didn't, and what still needs a decision.
Skipping the read-back. The sender always thinks the note is clear, because the sender already knows everything. The only way to find out whether a handoff works is to have the receiver say back what they understood, as I-PASS does and as step 4 of the exercise above does.
Thinking handoffs are only for complex systems. You don't need a multi-agent system to benefit. Anyone who starts a fresh chat, delegates to a colleague, or sets up a bot that escalates to staff is doing handoffs already. The only question is whether they're done well.
Related elements
- Multi-agent Systems: teams of AI agents with different roles, where every boundary between roles is a handoff.
- Subagents: the other pattern, where a lead agent sends a helper off for a narrow job and keeps control.
- Orchestration: how the flow of work between agents, tools and people is organised as a whole.
- Agent: AI that takes actions towards a goal, the usual sender and receiver in a handoff.
- Human in the Loop: the person who reviews, approves or takes over, and so often receives the handoff.
- Customer Support: where the bot-to-person handoff matters most, and how to set one up.
- Context Window: the working space that's cleared with every new chat, which is why chat-to-chat handoffs are needed at all.
- Context Engineering: choosing what an AI sees, which is the core skill behind a good handoff note.
- Summarization: the skill of making something shorter without losing what matters, and its limits when a handoff depends on it.
- Memory: features that carry notes between chats, and why they don't replace a deliberate handoff.