MCP: agent → tools
Model Context Protocol. JSON-RPC 2.0 over streamable HTTP. Your agent stays in charge and CallMCP is a set of tools it calls: dial, text, join a meeting, read a transcript. Every tool says whether it is read-only or destructive.
callmcp.ai/mcpAgent communications · checked 2026-11-06
Agent communications means two things. Agents talking to other agents and tools, over protocols like A2A and MCP. And agents talking to people, over phone calls, texts, meetings and email. CallMCP covers both: your agent reaches it over MCP (live), A2A (beta) or REST, and it reaches people over a real phone line.
MCP connects an agent to tools. A2A connects an agent to another agent. With MCP, your agent asks a server what tools it has (tools/list) and calls one (tools/call), for example make_call. With A2A, an agent reads another agent's card, sends it a message (message/send) and gets a message back.
Model Context Protocol. JSON-RPC 2.0 over streamable HTTP. Your agent stays in charge and CallMCP is a set of tools it calls: dial, text, join a meeting, read a transcript. Every tool says whether it is read-only or destructive.
Agent2Agent. An agent publishes a card at /.well-known/agent-card.json saying what it does and where to reach it. Another agent sends it a message and keeps the thread going with a contextId. Neither side sees the other's tools.
They fit together. Your agent uses MCP to run a business's phone line. Someone else's agent, booking on behalf of a customer, uses A2A to ask that business a question and gets an answer from the same agent that picks up its phone.
Status as the product reports it, checked 2026-11-06.
| MCP | Live | 180+ tools: calls, SMS, meetings, email campaigns, numbers, webhooks. tools/list answers without a key.callmcp.ai/mcp (streamable HTTP) |
| A2A | Beta | message/send only, text in and out. No streaming, no task lifecycle. Public business inquiries; needs a live subscription.kaicalls.com/api/a2a?handle=… · card at /.well-known/agent-card.json |
| REST | Live | The same operations as plain HTTP routes, with an OpenAPI spec for key holders.kaicalls.com/api/v1 |
| Webhooks | Live | Signed events (HMAC-SHA256) for calls, texts and transcripts. connect_agent adds durable retries.set_webhook · connect_agent |
A carrier sells you a number and an API. CallMCP is the four layers above it, and the carrier underneath is swappable: DialStack, Telnyx and Twilio today.
Swappable. Health-checked every 10 minutes. Failover line on a different carrier.
CallMCP // SWITCHING & RUNTIME
Answers the call, asks the owner mid-call, hands off to a human
Checked on our side, on every action
One key, four ways in
Claude, ChatGPT, Cursor, your own code, or another agent
On a raw carrier you build
On CallMCP you call
make_callone tool call: consent-checked callbacks, an idempotency key so a retry never rings twiceconnect_agentroute texts and A2A messages to your own agenttools/listread every schema before you connectNumbers, the voice runtime, consent records, the approval queue, retries and carrier failover are already on our side.
Already run an agent? Keep it. connect_agent points a business at your agent's HTTPS receiver. New inbound text conversations then reach your agent as signed events with retries. With a2a_enabled: true, public A2A message/send goes to the same receiver, or to an A2A endpoint you already run via a2a_url.
{
"name": "connect_agent",
"arguments": {
"agent_id": "YOUR_KAI_AGENT_ID",
"external_agent_id": "my-agent",
"webhook_url": "https://your-agent.example.com/callmcp/events",
"idempotency_key": "connect-my-agent-1",
"a2a_enabled": true
// optional: "a2a_url": "https://your-agent.example.com/a2a"
}
}
// needs scopes agents:write, sms:write, webhooks:write
// the signing secret comes back once: store itIn your receiver, the KaiCalls SDK helper handleA2ARequest (TypeScript) or handle_a2a_request (Python) checks the signature and freshness, then hands the text to your agent. Phone audio is not routed to an external agent: the built-in voice runtime answers calls. Connecting grants no extra permissions and does not turn on a channel that isn't registered.
Any A2A client can send a public inquiry to a business on KaiCalls. GET on the same URL returns that business's own agent card.
POST https://www.kaicalls.com/api/a2a?handle=BUSINESS_ID_OR_PHONE
Content-Type: application/json
{
"jsonrpc": "2.0",
"id": "1",
"method": "message/send",
"params": {
"message": {
"role": "user",
"messageId": "msg-1",
"parts": [{ "kind": "text", "text": "Can we book a service visit Tuesday?" }]
}
}
}
// reply: a message with a contextId. Send it back to continue.Carrier-agnostic: DialStack, Telnyx and Twilio today
Existing numbers stay on the carrier they were bought on; nothing moves them for you. What keeps a business answering through a carrier problem is the failover line.
Agent communications covers two jobs. One is agents talking to other agents and to tools, through protocols such as A2A (Agent2Agent) and MCP (Model Context Protocol). The other is agents talking to people over real channels: phone calls, texts, meetings and email. CallMCP does both: other software reaches it over MCP, A2A (beta) or REST, and it reaches people over a real phone line, SMS, meetings and approved email campaigns.
MCP (Model Context Protocol) connects an agent to tools: the agent lists the tools a server offers and calls them, for example make_call. A2A (Agent2Agent) connects one agent to another agent: an agent reads the other side’s agent card and sends it a message, then gets a message back. MCP is how your agent uses CallMCP. A2A is how someone else’s agent can talk to a business that runs on it.
Yes, in beta. CallMCP publishes an agent card at callmcp.ai/.well-known/agent-card.json (A2A protocol version 0.3.0, JSON-RPC). Each business gets an A2A endpoint that answers message/send with text in and text out. Streaming and the task lifecycle are not supported, the endpoint is for public business inquiries, and the business needs a live subscription. We label it beta because the product does not yet report the A2A runtime as verified.
Yes. Call connect_agent with your agent’s HTTPS webhook. New inbound text conversations then go to your agent as signed events with retries. Add a2a_enabled: true and public A2A messages go to the same signed receiver (or to your existing A2A endpoint via a2a_url). The KaiCalls SDK helper handleA2ARequest (TypeScript) or handle_a2a_request (Python) checks the signature and hands the text to your agent. Live phone audio is not routed to an external agent; the built-in voice runtime answers calls.
No. The carrier is the bottom layer and it is swappable: DialStack, Telnyx and Twilio today. Above it CallMCP runs the voice agent that answers calls, asks the owner mid-call and hands off to a person; the rails (owner approval, consent, disclosures, idempotency, audit log); and the interfaces (MCP, A2A in beta, REST, signed webhooks). Each carrier account is health-checked every 10 minutes, new numbers go to a healthy carrier, and a failover line on a different carrier keeps calls answered when calls are forwarded to it.
Free key first. A real line is $2 for your first week, then Kai Backup $10/mo with no per-minute overage. See the SDK quickstart or the rails.