Agent communications · checked 2026-11-06

MCP, A2A and a real phone line in one interface

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.

What is A2A and MCP?

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.

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.

A2A: agent → agent

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.

What CallMCP supports, per protocol

Status as the product reports it, checked 2026-11-06.

MCPLive180+ tools: calls, SMS, meetings, email campaigns, numbers, webhooks. tools/list answers without a key.
callmcp.ai/mcp (streamable HTTP)
A2ABetamessage/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
RESTLiveThe same operations as plain HTTP routes, with an OpenAPI spec for key holders.
kaicalls.com/api/v1
WebhooksLiveSigned events (HMAC-SHA256) for calls, texts and transcripts. connect_agent adds durable retries.
set_webhook · connect_agent

What sits between a phone carrier and your 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.

Fig. 02 / Carrier → voice runtime → rails → interfaces → your agent
  1. Carriers

    Swappable. Health-checked every 10 minutes. Failover line on a different carrier.

    • DialStack
    • Telnyx
    • Twilio
  2. CallMCP // SWITCHING & RUNTIME

    1. Voice agent runtime

      Answers the call, asks the owner mid-call, hands off to a human

      • Answers
      • Asks the owner
      • Human handoff
    2. Rails

      Checked on our side, on every action

      • Owner approval
      • Consent
      • Disclosures
      • Idempotency
      • Audit log
    3. Interfaces

      One key, four ways in

      • MCPLive
      • A2ABeta
      • REST · OpenAPILive
      • WebhooksLive
  3. Your agent

    Claude, ChatGPT, Cursor, your own code, or another agent

    • Any MCP client
    • TypeScript · Python
    • Other agents

On a raw carrier you build

  • Buy and configure numbers
  • Wire up a voice pipeline (speech, model, call control)
  • Build a consent store and calling-hours checks
  • Build an owner approval queue
  • Write retries and idempotency
  • Set up a second carrier for failover

On CallMCP you call

  • make_callone tool call: consent-checked callbacks, an idempotency key so a retry never rings twice
  • connect_agentroute texts and A2A messages to your own agent
  • tools/listread every schema before you connect

Numbers, the voice runtime, consent records, the approval queue, retries and carrier failover are already on our side.

1 Connect your own agent

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 it

In 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.

2 Message a business over A2A Beta

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

Swap carriers without touching your agent

  • DialStackAdapter in the carrier registry
  • TelnyxAdapter in the carrier registry
  • TwilioAdapter in the carrier registry
  • One adapter per carrierEvery carrier sits behind the same interface. Your agent calls make_call, never a carrier API, so adding or dropping a carrier changes nothing on your side.
  • Health sweep every 10 minutesEach configured carrier account is probed every 10 minutes and marked up or down. One good check brings a carrier back.
  • New numbers go to a healthy carrierA carrier that is down is skipped. Among the healthy ones, a new number lands where the line gets what it needs (texting, branded caller ID), then by cost and priority.
  • A failover line on a different carrierA second number on another carrier answers exactly like the original line: same business, same agent, same routing. Forwarding calls to it keeps them answered if the primary carrier goes down, and outbound calls use it while that carrier is down.

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 FAQ

What is agent communications?

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.

What is A2A and MCP?

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.

Does CallMCP support A2A?

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.

Can I connect my own agent instead of the built-in one?

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.

Is CallMCP just a Telnyx or Twilio wrapper?

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.

Give your agent a number

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.