Lead agent, quote agent, case agent, order agent, renewals agent. The design looks tidy on a slide because it copies the object model, one agent per tab in the CRM. Customers don’t talk in tabs. Someone asks why the invoice is higher than the quote, and that one sentence touches three of the five.
A topic is a fine reason to group tools. I don’t think it’s a reason to create an agent. I’d split only where the permissions, the owning team or the release schedule differ, and until one of them does I’d keep a single agent whose tool list is filtered on every request.
What a hand-off takes away
Each agent in a multi-agent design has its own instructions, its own tools and its own view of the conversation. A hand-off moves the customer from one to the next. Whatever the first agent learned either travels with them or gets asked for again.
The frameworks give you the primitive and leave the contract to you. In the OpenAI Agents SDK, a hand-off shows up to the model as one more tool it can call, and the receiving agent gets the whole prior conversation unless you attach an input filter. Those defaults are reasonable for a demo. In a CRM the full transcript can include a margin figure the next agent has no business reading, and a trimmed transcript can lose the order number. Somebody has to decide that per boundary and write it down.
Take Rushmere Supply, a wholesaler I’ve made up along with its logs, which launched with exactly those five agents. The logs showed 3.1 hand-offs per conversation, and in 40% of those hand-offs the customer was asked a second time for an order number they’d already typed. Every agent worked when tested alone. The joins between them were where the conversations went wrong, and the joins had no tests because they had no spec.
Topics fit inside one agent
Agentforce already models this with topics, which I took apart in an earlier post: one conversation, several scoped jobs, and nothing to pass across.
The same idea works on any stack, because tool definitions are sent with every model call. The list is an argument, so it can be computed. A router step reads the intent and the requester’s permissions and passes along only the tools both allow. A rep without discount authority never has approve_discount in the list, and a model can’t call a tool it was never shown. The router is ordinary code doing a classification and a permission lookup, one of the workflow patterns I’d reach for before adding an agent. The check still belongs inside the action as well, which is part of why I prefer business actions over raw CRUD.
A shorter list also gives the model fewer ways to pick wrong.
Three differences that earn a boundary
Permissions come first. If the agent reading free text from customers also holds the refund tool, one persuasive message is all that stands between a stranger and your money. Refunds want a separate agent with separate credentials.
The owning team is the second. Billing’s prompts, tools and on-call rota belong to billing. If sales engineering can edit them in a shared agent, ownership is a fiction.
The third is the release schedule. A sales agent that ships weekly shouldn’t be frozen every quarter-end because it shares a deployment with something finance has locked.
A worksheet for each proposed split
Fill this in once per candidate. It’s deliberately boring.
candidate_split: billing_specialist
proposed_by: sales-platform
questions:
- id: permissions
ask: Does it need a permission the main agent must never hold?
answer: true # issues refunds and credits
- id: owner
ask: Does a different team own its prompts, tools and on-call?
answer: true # billing operations
- id: release
ask: Does it ship on a different schedule or change process?
answer: true # frozen at quarter close
- id: contract
ask: Can the state that crosses be listed as fixed fields on one page?
answer: true
- id: traffic
ask: Do most conversations finish without crossing this boundary?
answer: true # about one in three needs billing
decision_rule: >
Split only if at least one of permissions, owner or release is true,
and both contract and traffic are true. Otherwise make it a topic
on the existing agent with its own filtered tool list.
decision: split
The last two questions are the brakes. If you can’t write the contract, the boundary is in the wrong place. If most conversations cross it, you’ve cut through the middle of a job.
The record that crosses
Here is the contract as a JSON Schema. The sender builds this record from fields. It doesn’t forward the transcript.
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"title": "HandoffRecord",
"type": "object",
"additionalProperties": false,
"required": [
"handoff_id", "conversation_id", "from_agent", "to_agent",
"goal", "facts_gathered", "records_touched", "withheld_from_receiver"
],
"properties": {
"handoff_id": { "type": "string" },
"conversation_id": { "type": "string" },
"from_agent": { "type": "string" },
"to_agent": { "type": "string" },
"goal": {
"type": "string",
"description": "What the customer wants, in one sentence."
},
"facts_gathered": {
"type": "array",
"items": {
"type": "object",
"additionalProperties": false,
"required": ["name", "value", "source"],
"properties": {
"name": { "type": "string" },
"value": { "type": "string" },
"source": { "enum": ["customer_stated", "crm_record", "tool_result"] }
}
}
},
"records_touched": {
"type": "array",
"items": {
"type": "object",
"additionalProperties": false,
"required": ["object", "record_id", "action"],
"properties": {
"object": { "type": "string" },
"record_id": { "type": "string" },
"action": { "enum": ["read", "created", "updated"] }
}
}
},
"withheld_from_receiver": {
"type": "array",
"description": "Field or data categories deliberately left out.",
"items": { "type": "string" }
}
}
}
source is there so the receiver knows which facts to verify. An order number the customer typed is a claim, and one read from the CRM is a lookup. withheld_from_receiver looks odd until the first audit, when someone asks whether the billing agent could have seen discount approvals and you can answer from the log.
When the other agent isn’t yours
Google announced the Agent2Agent protocol in April and moved it to the Linux Foundation in June. It’s still pre-1.0, so treat this as an early look. Agents publish a card describing what they can do, and other agents send them tasks over HTTP. That standardizes how you reach an agent another vendor runs. It doesn’t decide what you’re allowed to tell it, so the record above still has to exist, and the withheld list probably gets longer.
Rushmere, redrawn
In the invented sequel, Rushmere collapses four of the five into one sales agent with topics and filtered tools. Billing stays separate: another team runs it and it holds the refund permission. Hand-offs drop from 3.1 per conversation to 0.4, and the order number travels in facts_gathered.
Both agents write to one conversation log, hand-off records included. Hand-offs per conversation is the number I’d keep on a chart. When it creeps above one, some boundary has drifted into the middle of a job, and the worksheet is due another pass.