AI agent handoff vs memory vs routing

What is the difference between handoff, memory, and routing?

Routing is an orchestration decision, memory is retained information, and a durable handoff is an accountable transfer of work. Routing answers who should act now. Memory answers what this runtime should remember. A durable handoff answers what another authenticated actor needs to verify and continue later.

What is the Continuity Boundary Test?

The Continuity Boundary Test chooses a pattern by asking whether work stays in the same run, stays in the same runtime, or crosses into another accountable actor or system. Use routing for the run boundary, memory for the runtime boundary, and a durable handoff for an accountability boundary. This prevents teams from treating every persistent state problem as memory.

Question 1: Does the work stay inside one active run?
Yes -> use routing or manager-style orchestration

Question 2: Must the same application recall it in a later turn or session?
Yes -> use runtime memory

Question 3: Must another model, person, tool, or team verify and continue it?
Yes -> publish a durable handoff

Pattern          Primary job                 Typical boundary             Durable evidence
Routing          Choose the next specialist   Agents inside one run         Optional
Runtime memory   Recall prior information     Turns, threads, or sessions   Runtime-dependent
Durable handoff  Transfer accountable work    Models, people, tools, teams  Required

Routing output: destination and delegated input
Memory output: recalled facts, preferences, or thread state
Handoff output: objective, current state, decisions, evidence, constraints, next action, owner

When should an agent system use routing?

Use routing when a coordinator or peer agent must choose the best specialist during an active workflow. OpenAI's Agents SDK models handoffs as delegation to another agent that takes over the conversation, while manager-style orchestration keeps a central agent in control. Both are execution patterns; neither automatically creates a provider-neutral record another system can resume tomorrow.

• The work remains inside one orchestrated run.
• The next agent can receive the current conversation or a filtered input.
• Tracing the execution is sufficient for operational debugging.
• No separate human review or cross-tool continuation is required yet.

When should an agent system use memory?

Use memory for information the same application should recall across turns or sessions, such as user preferences, prior interactions, or thread state. LangGraph distinguishes short-term thread state from long-term information shared across sessions. Memory can improve relevance, but its authorship, review model, portability, and retention policy still depend on the application that stores it.

• The information is useful to future runs but is not itself a work product.
• The application controls the memory namespace and retention lifecycle.
• A compact recall is more useful than preserving every supporting artifact.
• The information does not require revision-level approval by another actor.

When is a durable agent handoff required?

Use a durable handoff when responsibility crosses a model, person, tool, session, or company workflow and the receiver must verify what happened. The handoff should preserve the current objective and state alongside immutable files, decisions, unresolved review comments, the next action, and authenticated authorship.

• Work moves from Claude to Codex, Gemini, Cursor, ChatGPT, or another host.
• A human must inspect SQL, HTML, Markdown, images, or generated reports.
• A second agent needs the exact evidence rather than a reconstructed summary.
• The team needs access control, revision history, attribution, or retention.

How should routing, memory, and handoffs work together?

Use routing and local memory while work is active, then publish a durable checkpoint at a meaningful boundary. The receiving actor searches for that canonical handoff, verifies its identity and current revision, reads attached evidence and open annotations, and seeds its own working memory before continuing with a new immutable revision.

1. Route the task to the right specialist
2. Use runtime memory during the active run
3. Publish a handoff before crossing a model, session, person, or system boundary
4. Verify the receiving identity with handover.whoami
5. Read the current revision, artifacts, and open annotations
6. Continue with expectedRevisionId