Model Context Protocol
Run your call center from Claude Code. Zumu speaks MCP in both directions.
An MCP call center is one where the tools point both ways. Zumu registers the MCP servers you already run, so an agent can call your tools while a caller is still on the line. Zumu also ships its own MCP server behind OAuth, so Claude Code, Cursor, or any MCP client can operate your agents, calls, knowledge and reports.
- OAuth 2.0 with PKCE
- Claude Code and Cursor
- Your tools, called mid-call
- Agents, calls, knowledge, reports
The session
One request, two tool calls, one approval
This is what running a call center from an editor looks like. The operator asks in plain English. The client picks the tools. The write stops for an approval, the read was allow-listed earlier so it does not, and the answer comes back carrying the same reason codes the reports use.
I will update the prompt first, then pull the transfers.
Allow zumu to run update_agent_prompt?
1. Yes
2. Yes, and do not ask again for this tool
3. No, tell Claude what to do instead
Done. The after-hours agent is on the new greeting, and the revision before it is still there if you want it back. Yesterday’s transfers came back under four reason codes.
reason_code
caller_requested_human
outside_scope
frustration_detected
identity_check_failed
Each of those has the human leg recorded and graded, and none of those human minutes were billed.
Direction one · Zumu as an MCP server
Operate the org from the editor you already have open
Add the Zumu MCP server to Claude Code, Cursor, or any client that speaks the protocol. The product carries the copy-paste setup for the first two on its own MCP page, so connecting is a paste and an approval rather than a project.
The connection is a real OAuth 2.0 authorization code exchange with PKCE. The client registers itself through dynamic client registration, you approve it on a consent screen, and the token that comes back is scoped to your organization. There is no shared secret to paste into a config file and none sitting in your shell history.
Platform MCP
- list_calls
- get_call
- search_calls
- list_transfers
- update_agent_prompt
Knowledge MCP
- retrieve
- list_knowledge_bases
- get_document
Two families, written the way the server advertises them. The names above are the ones worth knowing on day one rather than the whole surface.
Direction two · Zumu as an MCP client
Your agent calls your own tools while the caller is still on the line
Register the MCP servers you already run, over HTTP or over stdio. Zumu discovers the tools they expose and registers them on the agent, sanitizing the names so they stay valid for the model. Booking a ride, checking an order, looking up a member: whatever your server does, the agent can do mid-call.
The unglamorous half matters more. Servers are prewarmed before the greeting, so the first tool call of a call is not the one that pays the connection cost. A tool that hangs is cut off and tried once more. A server that cannot be reached does not end the call, and every attempt, including the failed one, lands in that call’s tool trace in the session report.
- Transport
- HTTP or stdio
- Discovery
- Tools registered on the agent automatically
- Timeout
- 12 seconds per tool call, then one retry
- Prewarm
- Servers warmed before the greeting plays
- Failure
- The agent keeps the call and says so
- Evidence
- Every call carries a tool trace in its session report
Twelve seconds is the shipped default rather than a constant, and the retry is a single one. A tool that is slow twice is a tool your caller waits on, so the agent covers the wait out loud instead of going quiet.
What this replaces
11pm
The greeting is wrong and the fix is one sentence long
Getting to that one sentence is the part that costs you the evening. Sign in. Find the agent among the others. Open the right group in the editor. Change the prompt. Save the revision. Then open a second surface to work out whether last night’s transfers were about the same thing, because that is the actual question and the greeting was only a guess at it.
None of that is hard. All of it is friction, and friction at 11pm is how a wrong greeting stays wrong until Monday. With the MCP server connected, the same fix is a sentence typed where you already are. The clicking is the part that goes away.
- The revision history still records the change, and the previous version is still one restore away.
- The transfer reasons still come from the same reports your supervisors read in the morning.
- Your team still gets the calls that need a person. This moves the console, not the work.
Where this fits
MCP is one of three doors into the same platform
- REST
Platform API
The same surface without an MCP client in front of it. A versioned REST API with a published OpenAPI document and organization-scoped keys.
Read the API docs - Events
Webhooks
For the direction neither protocol covers: Zumu telling your systems what happened, signed, retried, replayable, without anyone polling for it.
See the event surface - Architecture
The platform underneath
Where the MCP surface sits relative to the agent runtime, the knowledge stores and the tenancy model that scopes all three.
See the platform
Questions
What developers ask about the MCP surface
Still have questions?
Bring the client you already use. We will connect it to a Zumu organization and you can drive it yourself.
Book a demo
Connect it to your editor and make one real change
We will connect the MCP server to a Claude Code session on your side, change one thing about an agent through it, and then read the revision it wrote back out. Bring the change you have been putting off.
- No credit card for the demo
- OAuth, not a pasted key