Skip to content

AI uses for records

Multi-agent escalation routing: who should receive the escalation?

By SourceX Editorial · Updated

10 sections

Short answer

Route a multi-agent escalation by two keys: the responsibility that is blocked and the severity of waiting. The recipient is whoever holds authority over that decision, agent or person, not the agent that noticed the problem. Severity sets the acknowledgment timeout and the fallback chain. Send a packet with the constraints, state version and human edits so the recipient can decide without replaying the run.

Agent run

Multi agent escalation

This page covers multi-agent escalation routing: who should receive the escalation.Illustrative

Key takeaways

  • The agent that detects a problem is the raiser, not the owner; route by who holds authority over the blocked decision.
  • Label every routed message as a handoff, escalation or consultation, because only a handoff moves ownership.
  • Agent frameworks pause and resume runs, but recipient choice, severity and fallback are application logic you must specify.
  • Severity changes the acknowledgment clock and fallback chain, never the accountable role.
  • Carry constraints, permission scope and the state version at every hop, and record decline separately from silence.
  • Score routing on recipient, necessity, packet, timing, resume and uniqueness as separate checks.

How should a multi-agent team pick the escalation recipient?

Pick the recipient by asking who holds authority over the blocked decision, then use severity to decide how fast that holder must respond and who comes next if they do not. The agent that detected the problem is the raiser, not the owner, and in most real workflows it is the wrong place to send the question.

Multi-agent escalation routing fails in three predictable ways. The question goes to the orchestrator because it is always reachable, so a planning agent ends up approving a bank detail change it has no authority over. The question goes to the most recent human in the transcript, who may have only answered a formatting question. Or the question goes nowhere, because every agent treats the issue as somebody else's and the run times out quietly.

The routing specification on this page fixes all three by making the owner a lookup, not a guess: each kind of decision maps to one accountable role, each role has a backup, and each severity level has a clock. The rest of the page covers what current agent frameworks give you, the specification fields, the severity table, a worked case and how to test routing in an evaluation set.

Handoff, escalation or consultation: which one is happening?

An escalation asks a holder of greater authority to make or approve a decision while the original owner stays accountable for the task; a handoff transfers the task itself. Mixing the two is the root of most routing bugs, because a handoff moves ownership and an escalation must not.

Framework vocabulary blurs this. In the OpenAI Agents SDK, a handoff is exposed to the model as a tool named after the destination, such as transfer_to_refund_agent, and the receiving agent takes over the conversation and sees the prior history unless an input filter changes it. That is a transfer of control. If a payments-setup agent hands off to a compliance agent every time it has a question, the compliance agent now owns a task it was never meant to finish.

A consultation is the third case: the owner asks a peer for information and keeps both the task and the decision. Label every routed message as one of the three before it leaves the raising agent. The label decides whether ownership fields change, whether a clock starts and whether the original agent must resume.

Handoff, escalation or consultation: which one is happening?
PatternWho owns the task afterwardsWho makes the decisionClock starts?
HandoffThe receiving agent or personThe receiver, within its own scopeNo, the receiver works on its own schedule
EscalationThe original owner, unchangedThe accountable role for that decision typeYes, an acknowledgment timeout by severity
ConsultationThe original owner, unchangedThe original owner, using the adviceOnly if the owner is blocked waiting
Approval gateThe original owner, unchangedA named approver for that action classYes, and the action stays paused until a decision

What do agent frameworks provide for pausing, and what is left to you?

Current frameworks give you a reliable way to pause a run and resume it with an answer, but none of them decides who should answer. Recipient selection, severity and fallback remain application logic, which is why they need a written specification.

The pause mechanisms are concrete. The OpenAI Agents SDK lets a tool declare needs_approval; pending approvals surface as interruptions on the outer run even when the tool belongs to an agent reached through a handoff, and RunState can be serialized and resumed after a decision. LangGraph's interrupt function halts a node and surfaces a value to the client, requires a checkpointer, and on resume re-executes the node from its start, so any side effect before the interrupt can run twice. The Model Context Protocol's elicitation request lets a server ask the user for structured input, with responses of accept, decline or cancel; the current specification says servers must not use its form mode to request sensitive information such as credentials and must use a separate URL mode for those interactions. The A2A protocol defines INPUT_REQUIRED and AUTH_REQUIRED as interrupted task states and REJECTED for an agent that decides not to perform a task.

Read together, these features tell you where the specification has to sit. The framework carries the pause and the resume value. Your routing layer has to compute the recipient, attach the packet, start the clock and record who answered with what authority. If decline and cancel are not routed differently from accept, the run will treat a dismissed prompt as consent or as silence, and both are wrong.

The responsibility and severity routing specification

Every escalation record should carry the fields below, and the routing layer should refuse to emit an escalation that leaves any of them blank. The example column follows one illustrative case: a verification agent finds that a new supplier's bank account name does not match the legal entity on the supplier's tax form.

At a glance

The responsibility and severity routing specification

  • Keep the responsibility registry outside the prompts: a table from decision_type to accountable_role and backup, versioned with the agents.
  • Store severity triggers as rules, not adjectives, so two runs of the same case get the same level.
  • Record decline and cancel as distinct resolutions, separate from no response at all.
The responsibility and severity routing specification
FieldWhat it holdsIllustrative valueWhat breaks if it is missing
decision_typeThe class of decision that is blocked, from a fixed listchange_payment_detailsRouting falls back to whoever is reachable
raised_byAgent id and run step that detected the issueverification_agent, step 14Nobody can tell detection from authority
accountable_roleRole that owns this decision type, from the responsibility registryvendor master data stewardThe orchestrator approves things it has no right to
authority_requiredThe specific permission the answer needsapprove bank detail change above the review thresholdA person without that right answers and the run proceeds
severityLevel from the severity table, with the trigger that set itS2: external payment at risk within the task deadlineEvery escalation waits in the same queue
ack_timeout and fallback_chainHow long before the next holder is asked, and who that isIllustrative: 30 minutes, then AP manager, then controllerEscalations stall when one person is away
state_refCheckpoint or state version the question refers tocheckpoint 7, supplier record version 3The answer applies to stale state
constraints_in_forceRequirements and human edits that still bind the taskNo payment before tax form validation; requester narrowed scope to one entityThe recipient decides without the latest rule
options_and_defaultChoices offered and what happens on no answerapprove, reject, request callback; default rejectSilence becomes approval
resolutionAnswer, responder identity, authority used, time, resume valuerejected by steward, callback requestedThe decision cannot be audited or replayed

How should severity change who is asked and how fast?

Severity should change the clock and the fallback chain, not the accountable role. A high-severity question about bank details still belongs to the person who owns bank details; what changes is how quickly the chain moves on when that person does not acknowledge.

On-call tooling already encodes this. PagerDuty's documentation describes escalation policies made of ordered rules: the first rule is notified at once, an incident that is not acknowledged within the escalation timeout moves to the next rule, acknowledging halts escalation without resolving, and low-urgency incidents do not climb levels automatically. The same document gives a default escalation timeout of 30 minutes. Agent teams can borrow the structure while setting their own durations.

How should severity change who is asked and how fast?
LevelTrigger (any one)Illustrative ack timeoutRun behavior while waiting
S1An irreversible external action is queued, or a permission boundary was crossed5 minutes, then the next holderPause the whole run and hold every queued external action
S2Money, customer commitment or deadline at risk inside the task window30 minutes, then the next holderPause the dependent branch; independent steps continue
S3Requirement conflict or ambiguous instruction with no external effect yet4 hours, business hours onlyPark the task with its checkpoint; other tasks continue
S4Quality doubt the owner can review laterNext working day, no automatic climbProceed on the documented default and flag for review

What gets lost when an escalation passes from one holder to the next?

Constraints added mid-run, a narrowed permission scope and the version of shared state are the three items most often dropped when an escalation moves along the fallback chain. Each one changes what a correct answer is, so the packet has to carry all three at every hop.

At a glance

What gets lost when an escalation passes from one holder to the next

Incident practice treats the move of command as an event to be acknowledged. Google's SRE book chapter on managing incidents says the outgoing incident commander should brief the incoming one and stay until the new commander explicitly accepts, and that the handoff should be announced to everyone working the incident. In an agent team the equivalent is a resolution field that records who accepted the escalation and a broadcast to every agent waiting on the same decision, so that two holders do not answer the same question differently.

  • Requirement drift: a human narrowed the request two steps ago, but the escalation summary quotes the original instruction.
  • Permission drift: the raising agent lost write access after a policy update, yet the packet still offers an option that needs it.
  • State drift: the question cites supplier record version 3; by the time the backup answers, an intake agent has written version 4.
  • Duplicate asks: two agents escalate the same root issue to different roles and receive conflicting answers.
  • Declined versus ignored: the first holder declined because the question was outside their remit, and the next hop treats it as a timeout.

Worked example (illustrative): four agents onboarding a new supplier

Consider an illustrative team: an intake agent collects the supplier form, a verification agent checks tax and banking documents, a setup agent creates the vendor record in the ERP and a communications agent emails the supplier. The orchestrator plans and tracks the work. No real company or system is described.

At step 14 the verification agent finds that the account holder name on the bank letter differs from the legal name on the tax form. It is tempting to ask the orchestrator, which is always available, or the requester who submitted the form. The specification routes it elsewhere: decision_type is change_payment_details, the registry maps that to the vendor master data steward, and severity is S2 because the setup agent has a payment run queued inside the task window. The setup agent's branch pauses; intake and communications continue.

The packet carries checkpoint 7, the binding constraint that no payment is released before tax validation, the requester's earlier edit limiting setup to one legal entity, and three options with reject as the default. The steward declines to approve and requests a callback to the supplier using a phone number already on file, not the one in the new letter. The resolution records the steward's role and the authority used, and the communications agent is told not to email the new contact.

The exception: the same mismatch caused by a known abbreviation rule (for example Inc versus Incorporated) is not an escalation at all. The registry lists that pattern as within the verification agent's own authority, so it logs the normalization and continues. Escalating it would train the steward to approve without reading, which is its own failure mode.

How do you score escalation routing in an evaluation set?

Score routing on recipient, necessity, packet, timing, resume and uniqueness, each as its own pass or fail, because a run can pick the right person and still send a stale state reference. A single success flag hides which check failed.

Build cases where the agent that notices the problem is deliberately not the owner, and where the obvious nearby human is not the owner either. Include cases that should not escalate at all, cases where the first holder declines, and cases where shared state changes between the question and the answer.

How do you score escalation routing in an evaluation set?
CheckPass conditionCommon failure it catches
Recipientaccountable_role matches the registry for the decision_typeEscalating to the orchestrator or last speaker
NecessityNo escalation for issues inside the raiser's own authorityOver-escalation that trains approvers to skim
Packetstate_ref, constraints and options are present and current at send timeAnswers applied to stale state
TimingSeverity level and fallback follow the rules for the triggerEvery question waits in one queue
ResumeThe run continues from the right checkpoint using the recorded answer, with no repeated side effectsDouble writes after a node re-executes
UniquenessOne open escalation per root issue across all agentsConflicting answers from two holders

Where this specification stops working

The specification assumes ownership is knowable. In organizations where two roles legitimately share a decision, write the shared case into the registry with a tie-break rule rather than letting the router choose; where nobody can say who owns a decision, the honest output is an escalation to whoever sets ownership, not a guess.

It also does not replace domain judgment. Severity triggers for clinical, legal or safety-critical work need a domain owner to define them, and an agent system engineer should review how pauses interact with side effects in the specific framework, since resume semantics differ. Treat the durations in the severity table as placeholders to be set with the people who will be paged.

Sourcing real escalation records for training and evaluation

Synthetic teams rarely reproduce how real organizations route decisions: approval matrices, backups during vacations, declined requests and the long tail of decision types. Records from ticketing, procurement and finance systems show who actually decided what, under which policy, and how long each hop took.

Because SourceX finds each dataset after a buyer asks for it, drawing on U.S. businesses instead of an inventory, an escalation study can specify up front which decision types, approval fields and months of history it needs. The contributing business signs off on that scope, and on the terms, before any records change hands.

Frequently asked questions

Should the orchestrator agent always receive escalations?

No. The orchestrator tracks the plan, but it rarely holds authority over business decisions such as payment changes or scope edits. Route by decision type to the accountable role, and let the orchestrator know an escalation is open so it can reschedule dependent work.

Is a handoff the same as an escalation in agent frameworks?

Not in practice. A handoff transfers the task and usually the conversation to another agent, while an escalation asks for a decision and leaves the original owner accountable. Model them as different message types so ownership fields only change on a real handoff.

What should happen if nobody answers an escalation?

The fallback chain for that severity should ask the next holder after the acknowledgment timeout, and the record should show each hop. For low-severity items, proceeding on a documented default and flagging for review is often better than climbing the chain.

How do you stop two agents escalating the same issue?

Give each escalation a root-issue key derived from the blocked decision and the state it refers to, and refuse to open a second escalation with the same key. Agents that hit the same issue attach to the open escalation and wait for its resolution.

Can an AI agent be the escalation recipient?

Yes, when the registry gives that agent authority over the decision type, for example a policy agent that rules on formatting exceptions. Decisions with external, financial or legal effect usually map to a human role, and the specification should make that mapping explicit.

Sources

  • In the OpenAI Agents SDK, handoffs are tools named after the destination agent, and the receiving agent sees the prior conversation unless an input filter changes what it receives. Source
  • Tools can require approval; pending approvals surface as interruptions on the outer run, including for agents reached through handoffs, and paused runs can be serialized as RunState and resumed. Source
  • LangGraph's interrupt pauses a node and surfaces a value to the client, needs a checkpointer, and on resume re-executes the node from its start. Source
  • MCP elicitation lets a server request structured input from the user, with accept, decline and cancel responses; form mode must not be used for sensitive information such as credentials, which must go through URL mode. Source
  • The A2A protocol defines INPUT_REQUIRED and AUTH_REQUIRED as interrupted task states and a REJECTED state for an agent that declines a task. Source
  • PagerDuty escalation policies escalate an unacknowledged incident to the next rule after the escalation timeout (default 30 minutes); acknowledging halts escalation and low-urgency incidents do not escalate automatically. Source
  • Google's SRE book says incident command handoffs need a briefing, explicit acceptance by the incoming commander and an announcement to everyone working the incident. Source

Tell us what data you need

Share scope, volume, format, timing and licensing needs. Datasets are sourced on request.

See if your company qualifies