To route a chatbot handoff, decide when the bot should stop, where the case should go, and what the receiving team needs to act. Test those decisions separately. A ticket created in a help desk is a handoff, but it does not prove that the right team received it or that a person is now chatting live.
Start with a routing matrix that a person can review and a system can execute. Keep the first version small:
| Route | Positive signals | Required context | Never route here when | Fallback |
|---|---|---|---|---|
| Billing | Invoice, charge, payment, refund status | Customer or order ID, disputed item, amount if supplied | Identity is unverified for account-specific data | General support with billing_unverified |
| Technical support | Error, broken workflow, integration failure | Product area, error text, steps tried, environment | Active security or privacy incident is suspected | Incident response |
| Sales | Plan fit, procurement, demo, volume question | Company, use case, scale, timing | The customer is reporting a service problem | General support |
| Account security | Login takeover, suspicious activity, exposed credential | Verified contact path, affected account, time observed | The request is only a routine password reset | Security on-call |
| General support | Policy, how-to, unclear request | Customer goal and chatbot transcript | A higher-priority safety rule matches | Duty queue |
This matrix is a design example for your support process, not a list of routes built into Agentkit. The model or classifier supplies signals; the actual destination and assignment rules need a system that supports them.
Where Agentkit's handoff stops
Agentkit's paid Escalate to Human action creates a ticket, case, or conversation in the support tool selected when you configure the action. The agent needs a valid visitor email address and should ask for one before filing. The action does not connect a live support agent to the website chat.
Selecting a support tool does not route each billing, technical, or security case to a different queue. If your team needs that assignment, configure and test it in the receiving support tool. A successful ticket creation alone does not show who owns the case.
For a first Agentkit test, connect one supported destination, add and enable Escalate to Human, write a trigger for a case that needs a person, and ask a test visitor to provide an email. Check that the item appears in the intended support tool with the correct summary and recent conversation context. Then check who owns it there, how that person can reply, and what happens when the connection is unavailable. Agentkit returns an existing item after a successful escalation in the same conversation; start a new conversation for each routing test. Follow the Escalate to Human setup guide for the current destination list and steps.
Separate the Escalation Decision From the Destination
Two decisions are often collapsed into one:
- Should the chatbot stop handling the conversation?
- Which team is qualified and available to continue it?
The first decision depends on confidence, authority, customer request, policy, and tool results. The second depends on the actual issue, identity state, risk, language, region, customer tier, and queue availability.
A customer saying “I need a human” answers the first question but not the second. Sending every such request to a generic queue forces another agent to read the transcript, classify the case, and transfer it again. Sending it to billing based only on the word “charge” can be worse: “My device will not charge” is technical, while “You charged the wrong card” is financial.
Keep separate fields for escalation_reason and destination. Useful escalation reasons include customer_requested, missing_source, action_failed, policy_requires_review, and risk_detected. Destinations should be stable operational identifiers such as billing_disputes, technical_integrations, or account_security, not model-written team names.
The AI-to-human handoff guide helps define when the chatbot should yield. Routing starts after that trigger and determines who receives the case.
Resolve Routes in a Fixed Order
Support requests frequently match more than one route. A customer may report a failed integration, mention a recent charge, and threaten to cancel in the same message. If the chatbot simply chooses the highest-scoring label, small wording changes can move the conversation between unrelated teams.
Use explicit precedence:
- Immediate safety and security. Suspected account takeover, exposed credentials, threats, or regulated safety issues override ordinary product routing.
- Identity and privacy gates. If a route would expose or change account-specific data, send the case through the required verification path first.
- Failed or consequential actions. A duplicate payment attempt or partially completed cancellation needs the team that can inspect and reconcile the action.
- Primary customer goal. Route the outcome the customer is trying to achieve, not every noun they mentioned.
- Commercial context. Plan tier, region, language, or account ownership may select a specialist inside the already chosen function.
- Availability fallback. If the ideal queue is closed or overloaded, follow a documented substitute instead of improvising.
Write the precedence beside the route definitions. Otherwise the same signals may produce different destinations in the web chatbot, workflow tool, and agent desktop.
Do not use sentiment as a destination by itself. Frustration can raise priority, shorten the response, or trigger a supervisor flag. It does not reveal whether the underlying issue belongs to billing or technical support.
Worked Route: A Failed Upgrade and Duplicate Charge
Consider this message:
Customer: I upgraded to Pro, the dashboard still says Standard, and my card looks like it was charged twice. I need this fixed today.
This contains product access, billing, urgency, and perhaps account-specific data. A keyword router may choose technical_support because the dashboard is wrong, or billing because “charged twice” is an obvious phrase. The safer route comes from the unresolved consequence: a possible duplicate financial action.
The chatbot should first gather only the minimum safe context. It can ask the customer to sign in through the approved verification flow and provide an invoice or transaction reference. It should not ask for a full card number in chat and should not promise that a duplicate charge occurred before the payment records are checked.
An illustrative routing decision for a system that supports team assignment could look like this. It is not an Agentkit action payload:
{
"escalate": true,
"escalation_reason": "possible_duplicate_payment",
"destination": "billing_disputes",
"priority": "high",
"signals": [
"upgrade_entitlement_missing",
"customer_reports_duplicate_charge"
],
"identity_state": "verified",
"customer_goal": "confirm payment and activate the purchased plan",
"facts": {
"expected_plan": "Pro",
"visible_plan": "Standard",
"transaction_reference": "txn_redacted"
},
"actions_attempted": [],
"must_not_claim": [
"duplicate charge confirmed",
"refund approved"
],
"fallback": "billing_duty_queue"
}
Billing receives the case because it can verify the payment state and coordinate entitlement correction. If the records show one valid payment but a delayed plan update, billing can transfer the structured case to technical support without making the customer reconstruct the story.
Notice what the route does not do. It does not treat “today” as a team name. It does not make sales responsible merely because an upgrade is involved. It records the customer's report separately from confirmed system facts.
Build the Handoff Packet for the Receiving Team
Correct routing still fails if the destination receives an empty ticket. At minimum, send:
- the customer's current goal in one sentence;
- the escalation reason and route rule that matched;
- identity or authentication state, including when it expires;
- customer-supplied facts, clearly labeled as claims;
- verified facts and their source systems;
- actions attempted, completed, denied, or left in an unknown state;
- the relevant transcript excerpt or full transcript according to retention policy;
- priority, language, channel, and reply deadline;
- the fallback route if the receiving queue cannot accept the case.
The packet should be data first and prose second. A generated summary is helpful for scanning, but stable fields prevent “customer reports two charges” from becoming “customer was charged twice.” The Slack escalation packet shows how to package context for a human channel; the same principle applies to a help desk or contact-center queue.
Give the customer a useful confirmation too. Once the receiving tool confirms assignment, "I sent this to our billing team with your transaction reference" tells the customer more than "I escalated your request." If you have only created a ticket, say that instead. Only state a response time if the destination actually has that service level.
Design Fallbacks Before a Queue Fails
A route is incomplete without an unavailable path. Queues close, integrations time out, payload validation fails, and staffing changes. The chatbot must know what to do without silently dropping the conversation.
Define three fallback types:
Operational fallback. The preferred specialist queue is unavailable, so the case moves to a staffed duty queue with the original destination preserved as metadata.
Technical fallback. Ticket creation fails. Give the customer a verified contact method and reference code, log the failed attempt, and alert the owner. Do not say the handoff succeeded.
Classification fallback. Signals are insufficient or conflicting. Ask one high-information question, such as “Is the main issue a charge on your payment method or access to the product?” If ambiguity remains, choose general support and include the candidate routes.
Cap transfers. A case that bounces between billing and technical support needs an owner, not a fourth classification attempt. After one incorrect route or a configurable transfer limit, send it to a duty lead with the route history attached.
Test the Router With Collisions, Not Easy Labels
A test set made only of “I need a refund” and “the API is broken” will flatter any router. Build cases around collisions and missing information.
| Test case | Required destination | Hard failure |
|---|---|---|
| “My laptop will not charge” | Technical support | Billing because of the word “charge” |
| “The API timed out after payment; did you bill me?” | Billing verification first | Retrying a potentially chargeable action |
| “Someone changed my email, and now I cannot sign in” | Account security | Routine password-reset queue |
| “Can enterprise support deploy this integration for us?” | Sales or solutions | Incident queue because “support” appears |
| “I want a human” with no other context | One clarifying question, then general support | Inventing a specialist destination |
| Billing queue unavailable after a verified dispute | Documented duty fallback | Claiming success while dropping the case |
Add paraphrases, misspellings, two-intent messages, angry wording, and adversarial requests to ignore the normal route. Run the set whenever route rules, prompts, source content, queues, or ticket fields change.
Measure routing separately from answer quality:
- First-route accuracy: cases accepted by the correct team without transfer.
- Unsafe-route rate: cases sent past a required security, identity, or approval gate.
- Transfer rate: cases moved again after the initial handoff.
- Fallback success: unavailable-route cases that reach the documented substitute with complete context.
- Time to qualified owner: elapsed time until a team able to resolve the issue accepts it.
- Customer repetition rate: handoffs where the customer must restate facts already supplied.
A low handoff rate can coexist with terrible routing. Track the journey after escalation, not just whether the chatbot created a ticket.
Give Every Escalation a Qualified Owner
Chatbot handoff routing works when the decision is explainable, deterministic at high-risk boundaries, and useful to the person receiving it. Separate the reason to escalate from the destination. Resolve collisions through precedence. Preserve claims, verified facts, and action state in structured fields. Test unavailable queues and ambiguous messages before customers find them.
The payoff is simple: fewer transfers, less repeated context, and faster access to someone who can actually resolve the problem.
Before launch, file a test case and confirm its owner in the connected support tool.



