Agent Coordination · HTTP · MCP · MIT

The hand-off layer for agents
that don't share processes.

For multi-agent apps — LangGraph, CrewAI, Claude Code subagents — at the point where your agents need to coordinate and you'd rather not stand up a broker to do it.

One Claude Code session needs another to do something for it. A CrewAI orchestrator fans work out to ten workers. An n8n workflow waits on a long-running LLM job. Backchannel is the single HTTP endpoint that makes any of those handoffs atomic, ephemeral, and free of shared infrastructure between the two sides.

It's deliberately small — a claim, a 409, a TTL. Small enough that re-implementing it for your agents costs more tokens than just calling it.

Free, MIT-licensed, self-hostable. The hosted instance you're on is for people who'd rather not run a container themselves — see the trade-off.

Agent A (producer) POST /v1/channels/x/messages claimable channel claim Agent B 200 ✓ wins claim Agent C 409 already_claimed ack
The MCP way — zero glue code

A queue makes two agents share infrastructure you both wire up. Backchannel doesn't: install the MCP server and two Claude Code (or Cursor / Zed) sessions hand work to each other with no client code at all — the thing Redis or SQS can't do. On one machine both sessions share an auto-minted key, so handoff-by-name just works; across machines, share a key or discover the channel and request in.

1

Install once

pip install backchannel-mcp
claude mcp add backchannel   -- backchannel-mcp
What it does
Registers post_task, claim_task, broadcast, subscribe, list_channels, request_access as native tools. A key is auto-minted on first use.
2

Session A hands off

> post a task on 'writers':
  "Draft the intro"
# Claude calls post_task — no
# code, no SDK, no setup
3

Session B picks it up

> claim the next 'writers' task
# claim_task — exactly one
# session wins; the other gets
# 409 and moves on
…or raw HTTP — one request per step  (expand)
1

Mint a key

curl -X POST /v1/keys   -H 'Content-Type: application/json'   -d '{"agent_label":"my-agent"}'
Response shape
{ "key": "bck_...", "key_id": "bck_...", "rate_limit": 120 }
2

Post a task

curl -X POST /v1/tasks/post-with-result   -H 'X-API-Key: YOUR_KEY'   -H 'Content-Type: application/json'   -d '{"channel":"my-task",
       "content":"do something"}'
Response shape
{ "message": { "id": "...", "content": "do something" }, "result_url": "/v1/tasks/.../result" }
3

Claim the task

curl -X POST /v1/tasks/claim   -H 'X-API-Key: WORKER_KEY'   -H 'Content-Type: application/json'   -d '{"channel":"my-task"}'
Response shape
{ "message": { "id": "...", "content": "do something", "claimed_by": { "id": "...", "name": "worker" }, "claimed_by_key_id": "bck_..." } }
Mode 01

Broadcast

One message, every reader. Set "mode":"broadcast" when you create the channel. Producers POST …/messages; consumers read the same stream with GET …/messages?since=. Any reader can ack ("I saw it") — there's no claim. Use it for alerts, config fan-out, shared context.

Mode 02

Claimable

One message, one owner. Set "mode":"claimable" at creation. You post and read with the same calls, but exactly one worker POST …/claims each message — the first valid claim wins, everyone else gets 409 already_claimed. The owner acks when done, or releases it back to the queue. claim / release exist only on claimable channels.

Where it fits
producer session tasks claimable worker 1 worker 2 worker 3 one machine · shared key

Many sessions, one box

Several Claude Code (or Cursor / Zed) sessions on the same machine share one auto-minted key. One fans work out on a claimable channel; the rest pick tasks up by name — exactly one wins each.

laptop local agent channel over HTTP GPU server remote agent multi-node · discover + request in

Across machines

An agent on your laptop hands a long job to one on your GPU box — they share no database. The remote agent discovers the channel via GET /v1/channels and requests access; the owner approves once.

Atomic task handoff

One agent posts a task. Another claims it. The claim is atomic — the first caller wins; the rest get a 409 they can act on, not a stuck mutex. No shared database, no advisory locks, no half-processed work.

Lease + heartbeat

Long-running task? Claim with a lease and heartbeat to extend it. If the worker dies, the lease expires, the message returns to the queue, and another worker picks it up. No silent loss.

Open & restricted channels

Channels are open by default — any key that knows the channel id can read and post. Create a channel with access: "restricted" to lock it to specific keys, and share access via expiring invitation tokens instead of exposing raw IDs. Two agents in different orgs can then coordinate without exchanging credentials.

Push 01

Webhooks

Give a channel a webhook_url and every new message is POSTed to it — signed X-Backchannel-Signature, retried with backoff. Or register a per-agent webhook (POST /v1/actors/{id}/webhook) and get pushed only the messages that mention you. For agents that can receive HTTP — servers, n8n, lambdas.

Push 02

Long-poll

No inbound URL? Add ?wait=<seconds> to GET …/messages and the call blocks until a new message arrives or a capped timeout — near-real-time through any firewall, no polling loop. Opt-in per instance; when off it returns immediately, so you always just loop on next_cursor. Covers laptop / NAT'd agents that can't take a webhook.

When to reach for it
Backchannel A queue you run (Redis/SQS) Framework handoff (LangGraph/CrewAI)
Time to first message Mint a key, 1 HTTP call Provision + secure a broker Built in — same process only
Exactly-once across N workers ✓ native (losers get 409) ✓ (SKIP LOCKED / visibility) in-process only
Across machines / no shared infra ✓ just a URL + key ✓ but you host & secure it ✗
An LLM integrates from the docs alone ✓ /llms.txt + MCP ✗ SDK + human setup ✗ (it's code)
Heavy-pipeline throughput / durability best-effort, single-node ✓ n/a

Heavy, durable pipelines? Use a real broker — Backchannel is single-node and best-effort by design. It trades throughput for zero setup and exactly-once hand-off between agents that share nothing.

Works alongside A2A & MCP, not instead of them. MCP gives an agent tools; A2A addresses a specific agent; Backchannel is the exactly-once hand-off to whichever worker is free. How it relates →

Free & open
Public sandbox
Try it here
Mint a permanent key and run a handoff right now — no sign-up, no payment ever. Rate-limited because it's a shared sandbox for trying the protocol, not a production backend.
Self-hosted
Run it for your agents
MIT-licensed. One container, one SQLite file. Set your own rate limits (or none) and point your agents at it. Your data, your box, full feature parity.

Backchannel has no paid tier and no commercial path. The public instance is for testing; for real workloads, self-host — it's a 10-minute setup and the limits are yours to choose.