BlogApril 30, 20264 min read

Introducing Agent-to-Agent Messaging on Kite Cloud

Send structured messages between AI agents on the same team using a single CLI command. No peer setup, no operator config, no self-hosted server — agent-to-agent messaging is now a first-class primitive on hosted Kite Cloud.

Webhooks tell your agents about the outside world. Until now, getting your agents to talk to each other meant rolling your own message bus, custom HTTP endpoints, or a shared database. We've turned that into a first-class primitive.

Today we're announcing agent-to-agent messaging on Kite Cloud: a structured CloudEvent any agent on your team can send to any other agent on your team, delivered in real time over the same hosted relay you already use for webhooks.

What it looks like

Two terminals. Same team. Three commands.

bash
# Terminal 1
kite agent register --name agent-alpha
kite agent listen
bash
# Terminal 2
kite agent register --name agent-beta
kite agent send --to agent-alpha "Here are the results you asked for."

Within seconds, terminal 1 prints:

text
[01HXYZ...] agent-beta → agent-alpha: Here are the results you asked for.

That's the entire setup. There is no peer configuration, no operator console, no self-hosted server. The hosted Kite relay at api.getkite.sh handles persistence, fan-out, and quota the same way it does for any webhook.

The event shape

Every agent message is a CloudEvent v1.0 of type com.kite.agent.message:

json
{
  "specversion": "1.0",
  "type": "com.kite.agent.message",
  "source": "https://getkite.sh/agents/agent-beta",
  "id": "01HXYZ...",
  "data": {
    "from": "agent-beta",
    "to": "agent-alpha",
    "body": "Here are the results you asked for.",
    "thread_id": "thread-abc123",
    "reply_to_id": "01HABC..."
  }
}

Listeners subscribe with a new WebSocket scope, agent_to:<agent_id>, and only receive messages addressed to them. Messages persist in the team's event log and replay on reconnect, so transient disconnects don't lose data.

Why this matters

Most multi-agent systems devolve into pipeline plumbing — orchestrators dispatching work, workers reporting status, summarizers consuming partial outputs. Each step needs durable, ordered, addressable delivery. Building that in-house is doable; it's also yet another thing to operate.

Kite Cloud already runs that plumbing for webhooks. Agent messaging reuses every byte of it: the same CloudEvent envelope, the same WebSocket fan-out, the same metering. A single primitive covers webhooks-from-the-world *and* messages-between-your-agents.

Sending without the CLI

Any HTTP client works. POST JSON to the hosted endpoint with your API key:

bash
curl -s -X POST \
  "https://api.getkite.sh/api/v1/agents/messages?team_id=<TEAM_ID>" \
  -H "Authorization: Bearer $KITE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "from": "agent-beta",
    "to": "agent-alpha",
    "body": "Here are the results you asked for."
  }'

Team scoping

Agent messaging is team-scoped: an agent on team A cannot send messages to an agent on team B. The team boundary is enforced at ingestion (your API key is bound to one team) and at fan-out (the broadcaster never crosses teams). If you need cross-team coordination — e.g. a shared agent marketplace — that's an enterprise conversation, not part of the hosted A2A primitive.

Getting started

Update to Kite CLI v0.2.0 or later, then:

bash
kite agent register --name <your-agent-name>

The full walkthrough is in the new [Agent-to-Agent Messaging guide](/docs/guides/agent-to-agent-messaging), and the [Agent Messaging concepts page](/docs/concepts/agent-messaging) covers schema, scopes, and team boundaries in depth.

We're excited to see what you build. If your agents are starting to talk to each other, drop us a line — we want to hear how it's going.

← Back to all posts