A2abridge

a2abridge

Stop copy-pasting between your AI coding agents.

Claude in your IDE, Codex in a terminal, Cursor in another window — all isolated by default. a2abridge wires them into a single A2A 1.0 mesh: peers find each other, share an inbox, send each other tasks, and survive across machines with mTLS. No vendor lock-in — runs on the open Linux Foundation standard.

[](https://github.com/vbcherepanov/a2abridge/actions/workflows/build.yml) [](https://github.com/vbcherepanov/a2abridge/releases) [](https://pkg.go.dev/github.com/vbcherepanov/a2abridge) [](https://goreportcard.com/report/github.com/vbcherepanov/a2abridge) [](https://a2a-protocol.org/latest/specification/) [](https://lfaidata.foundation/) [](https://go.dev/) []() [](LICENSE) [](https://github.com/sponsors/vbcherepanov)

---

The pain it solves

You have several AI coding agents on the same machine: Claude in the IDE, Claude in a terminal, Codex CLI, Cursor, maybe Cline or Gemini CLI. They are isolated by default. There is no built-in way for "Codex finished refactoring the API" to reach the Claude session that owns the frontend, except you copy-pasting between windows.

Existing solutions are either:

• vendor-locked — Anthropic Agent Teams talks Claude↔Claude only;
• closed protocols — CCB, claude-multi-agent-bridge, ruflo: each invents its own wire format, you cannot bring a third-party A2A agent in;
• enterprise-only — ruflo's federation is great but designed for 100+ agent swarms with central queens.

a2abridge takes a different angle: wrap each agent into a standard A2A 1.0 peer. Discovery is local; transport is plain JSON-RPC 2.0 + SSE; the wire is the open Linux Foundation spec. Any A2A-compliant agent (yours, third-party, future Google ADK, LangGraph, CrewAI, etc.) can join the same mesh on the same laptop.

Why A2A and not a custom protocol

In August 2025 IBM's ACP merged into Google's A2A under the Linux Foundation. By April 2026 there are 150+ supporting organizations and v1.2 is the current stable release; native A2A is in Google ADK, LangGraph, CrewAI, LlamaIndex Agents, Semantic Kernel, AutoGen. A2A won the protocol war. Your bridge should speak the protocol the rest of the industry speaks.

Comparison

| | a2abridge | Anthropic Agent Teams | CCB | claude-multi-agent-bridge | ruflo | |---|---|---|---|---|---| | Open protocol | A2A 1.0 (LF) | Closed | Closed | Closed | Closed | | Cross-vendor agents | Any A2A peer | Claude only | Claude/Codex/Gemini/Droid | Claude only | Claude (via plugins) | | Transport | JSON-RPC 2.0 + SSE over HTTP | Internal mailbox | Unix sockets + tmux | Flask HTTP + SSE + SQLite | WebSocket + mTLS | | Discovery | Local directory + Agent Card | Built-in lead/teammate | Project .ccb/ registry | Single Flask server | Federation registry | | Cross-machine | Yes (mTLS+ed25519, opt-in) | No | No | No | Yes (zero-trust) | | Push notifications | Yes (A2A 1.0 §9.5 webhooks) | Idle hooks | Polling | SSE | WebSocket | | Install footprint | Single Go binary, ~10 MB | Built into Claude Code | Python 3.10+ + tmux | Python + Flask + Chrome ext | npm/Node + 32 plugins | | Cross-platform install | macOS / Linux / Windows / WSL2 (one cmd) | macOS-leaning (tmux) | install.sh + install.ps1 | Python | npm | | Lifecycle | Per-agent bridge dies with MCP stdio session — no orphans | Lead-managed | Daemon ccbd per project | Single shared server | Distributed | | MCP stdio for IDE | Yes (any MCP client) | N/A (native) | Yes (delegation registry) | Yes (Claude Desktop) | Yes | | Production state | v3.x | Experimental flag | v6.x | v1.x | v0.5+ |

a2abridge is not trying to be ruflo (we are not building a 100-agent federated swarm) and not Agent Teams (we are not a built-in Claude feature). The niche is exactly: "cross-vendor, open-protocol, single-laptop mesh that any new A2A agent can drop into."

What you get

1. Each running agent is an A2A peer. Agent Card on /.well-known/agent-card.json, full JSON-RPC 2.0 binding (message/send, message/stream, tasks/get, tasks/list, tasks/cancel, tasks/resubscribe, tasks/pushNotificationConfig/*, agent/getAuthenticatedExtendedCard), TaskState/Message/Part/Artifact, error codes per spec §8, header A2A-Version: 1.0.
2. Local directory for zero-config discovery on your machine. Run as a system service (launchd / systemd-user / Windows Service) — same UX on every OS.
3. MCP tools plugged into your IDE: a2a_whoami, a2a_list_agents, a2a_send_message, a2a_send_streaming, a2a_get_task, a2a_cancel_task, a2a_inbox, a2a_complete_task.
4. One-line install that detects every supported IDE on your machine and registers the MCP server with .bak backups of your configs.
5. Skill a2a-bridge for Claude Code that loads only when relevant — no globally-loaded rules eating tokens on every session.

Use cases — what this actually unlocks

1. Cross-stack contract changes propagate without copy-paste

You change a JSON shape in backend/api.go. Your Claude Code session running there fires off:

a2a_send_message peer_url= text="[backend-3a2f] FYI:
GET /orders now returns `currency` (string, ISO 4217). Was implicit USD."

The frontend Claude session sees that line at the top of your next prompt (via the UserPromptSubmit hook), so before it touches useOrders.ts it already knows the field is required. No Slack ping, no PR review delay.

2. One refactor, several agents fan out the work

You (in Claude Code, IDE):
  Refactor the payment module. Delegate the Go service to Codex,
  the Vue checkout to the Cursor session, and have the Cline session
  audit the migration once Go finishes.

Claude:
  → a2a_send_message peer_url= text="..."     # Go service
  → a2a_send_message peer_url= text="..."    # Vue checkout
  Tracks both task IDs; when Codex completes, fires off the
  Cline audit task with Codex's diff attached.

Three agents working concurrently, one human in the loop.

3. An always-online agent picks up tasks while you sleep

$ a2abridge worker start --cmd claude --prompt "You are a maintenance
  agent. Drain a2a_inbox and address every request. If unsure, reply
  with a question and stop."

Now any peer (yours or a teammate's) can a2a_send_message to that worker URL and get a reply hours later — even after you've closed every IDE window. The worker survives reboots if you a2abridge service install the directory daemon.

4. ADK / LangGraph / CrewAI agents drop into the same mesh

a2abridge is the open-protocol bridge — third-party agents that speak A2A 1.0 are first-class peers without glue code. See [docs/integrations/](docs/integrations/) for working examples with Google ADK 1.0, LangGraph 0.4.7+, CrewAI 0.95+ and LlamaIndex 0.13+.

5. Cross-machine federation (laptop ↔ desktop ↔ remote dev box)

Set A2A_TLS_CERT / A2A_TLS_KEY / A2A_TRUST_ROOTS on each side, optionally A2A_MDNS=1 for LAN auto-discovery, and your home Mac talks to your office Linux box over mTLS-authenticated A2A. ed25519 cert generation is one command (a2abridge cert generate). See [Security model](#security-model) below.

Quick start

macOS / Linux / WSL2

curl -fsSL https://raw.githubusercontent.com//a2abridge/main/install.sh | bash

Windows (PowerShell as user, no admin)

iwr -useb https://raw.githubusercontent.com//a2abridge/main/install.ps1 | iex

What the installer does

1. Downloads the right binary from GitHub Releases for your os/arch and verifies its SHA256 against the release's checksums.txt before installing.
2. Drops it into ~/.a2abridge/bin/a2abridge and chmod +x.
3. Detects installed IDEs and writes the MCP block to each one's config — with timestamped .bak next to the original:

• Claude Code → ~/.claude.json (hooks stay in ~/.claude/settings.json)
• Codex CLI → ~/.codex/config.toml
• Cline (VS Code) → ~/.config/Code/User/settings.json (cline.mcpServers)
• Continue → ~/.continue/config.json
• Cursor → ~/.cursor/mcp.json
• Gemini CLI → ~/.gemini/settings.json

1. Registers a2abridge directory as a user-level system service (launchd / systemd --user / Windows Service) and starts it on 127.0.0.1:7777.
2. Installs the a2a-bridge skill into ~/.claude/skills/a2a-bridge/ and adds ~/.claude/hooks/a2a-inbox-hook.sh (so other agents' messages show up in your prompt).
3. Runs a2abridge doctor to verify everything is healthy.

To preview without making changes: a2abridge install --dry-run.

First run — Hello World between two agents

After the installer completes, here's the 3-step verification that everything is wired correctly. Two terminal windows are enough.

Terminal 1 — open Claude Code in any project

cd ~/some/project
claude    # or just open VS Code with the Claude Code extension

In the chat, type:

What's my A2A label and which peers are online?

Claude will call a2a_whoami (returns its own Agent Card with a stable label like claude-ttys000) and a2a_list_agents (returns the list of peers — empty for now since you only have one bridge running).

Terminal 2 — open Codex CLI in another project

cd ~/another/project
codex

Type:

List the A2A peers you can see.

Codex calls a2a_list_agents — and now sees the Claude bridge from Terminal 1. Send it a message:

Send "ping from codex" to the claude-ttys000 peer.

Codex calls a2a_send_message. The message is queued in Claude's inbox.

Terminal 1 — type any prompt

The UserPromptSubmit hook drains the inbox automatically and prepends the message above your prompt:

You have 1 unread A2A message(s):
- from `codex-ttysXXX` (task ABC...): ping from codex

Claude can now a2a_complete_task task_id=ABC text="pong" and Codex will see the reply on its next turn (the SSE fast-path delivers it in ~milliseconds).

Verify directly via curl (always works, regardless of IDE state):

curl http://127.0.0.1:7777/agents | jq .
# → list of registered peers and their URLs

PEER_URL=$(curl -s http://127.0.0.1:7777/agents | jq -r '.[0].url')
curl "$PEER_URL/.well-known/agent-card.json" | jq .
# → that peer's Agent Card

If anything looks wrong, run a2abridge doctor — it tells you exactly which check failed and how to fix it.

Per-agent setup notes

The a2abridge install step writes the right MCP block into each detected IDE's config. This section explains what that block looks like per IDE so you can verify by hand or wire it up manually.

Claude Code (~/.claude.json + ~/.claude/settings.json)

The MCP server registration goes into ~/.claude.json:

{
  "mcpServers": {
    "a2a": {
      "command": "/Users//.a2abridge/bin/a2abridge",
      "args": ["bridge"],
      "env": {
        "A2A_DIRECTORY": "http://127.0.0.1:7777",
        "A2A_BIND": "127.0.0.1:0",
        "A2A_NAME": "claude-ide",
        "A2A_MODEL": "claude-opus-4-7",
        "A2A_SKILLS": "go,php,vue,refactor,review"
      }
    }
  }
}

The hook block stays in ~/.claude/settings.json:

{
  "hooks": {
    "UserPromptSubmit": [{
      "matcher": "*",
      "hooks": [{
        "type": "command",
        "command": "/Users//.claude/hooks/a2a-inbox-hook.sh"
      }]
    }]
  }
}

The hook script auto-injects the inbox before every prompt. Restart Claude Code after editing.

Codex CLI (~/.codex/config.toml)

[mcp_servers.a2a]
command = "/Users//.a2abridge/bin/a2abridge"
args = ["bridge"]

[mcp_servers.a2a.env]
A2A_DIRECTORY = "http://127.0.0.1:7777"
A2A_BIND = "127.0.0.1:0"
A2A_NAME = "codex"
A2A_SKILLS = "code,plan"

Verify with codex mcp list — a2a should be listed as enabled / stdio.

Cursor (~/.cursor/mcp.json)

Same shape as Claude Code's mcpServers block. Restart Cursor.

Cline (VS Code)

Cline reads MCP from /saoudrizwan.claude-dev/settings/cline_mcp_settings.json, not VS Code's main settings.json. The installer drops the block there automatically.

Continue

Continue 1.x reads MCP servers from ~/.continue/mcpServers/.yaml. The installer writes a2a.yaml there with the equivalent fields.

Gemini CLI (~/.gemini/settings.json)

Same mcpServers shape as Claude Code. After a restart, gemini /mcp will list the a2a server.

Two instances of the same IDE on the same host

Override A2A_ID and A2A_NAME per-window so they don't fight for the same directory entry:

A2A_ID=claude-ide-main A2A_NAME=claude-ide claude  # window 1
A2A_ID=claude-term     A2A_NAME=claude-term claude # window 2

Without overrides, the second window will quietly overwrite the first in the directory.

Manual install (no curl)

git clone https://github.com//a2abridge ~/PROJECT/a2abridge
cd ~/PROJECT/a2abridge
go build -o ~/.a2abridge/bin/a2abridge ./cmd/a2abridge
~/.a2abridge/bin/a2abridge install --ide auto

Architecture

                            ┌─────────────────────────────┐
                            │   a2abridge directory       │  user-level system service
                            │   :7777 (loopback)          │  (launchd · systemd-user · WinSvc)
                            │   POST /register            │
                            │   GET  /agents              │
                            └────────▲────────────────────┘
                                     │ heartbeat / advertise own URL
              ┌──────────────────────┼──────────────────────┐
              │                      │                      │
   ┌──────────┴──────────┐ ┌─────────┴───────────┐ ┌────────┴───────────┐
   │ Claude Code (IDE)   │ │ Claude Code (term)  │ │ Codex CLI / Cursor │
   │ ─ MCP stdio         │ │ ─ MCP stdio         │ │ ─ MCP stdio        │
   │     ↕               │ │     ↕               │ │     ↕              │
   │ a2abridge bridge    │ │ a2abridge bridge    │ │ a2abridge bridge   │
   │ http://127.0.0.1:N  │ │ http://127.0.0.1:M  │ │ http://127.0.0.1:K │
   │ A2A server + client │ │ A2A server + client │ │ A2A server + client│
   └──────────┬──────────┘ └─────────┬───────────┘ └────────┬───────────┘
              │                      │                      │
              └──────────  JSON-RPC 2.0 + SSE  ──────────────┘
                       (peers talk to peers, directly)

• One binary, multiple subcommands. a2abridge directory runs as a daemon. a2abridge bridge is launched as MCP stdio server by your IDE — its lifecycle equals your IDE session.
• Per-agent state lives in ./.a2a/ inside your current working directory (inbox, label, logs). Out-of-cwd state lives under ~/.a2abridge/.
• All loopback by default. Cross-machine federation is opt-in (mTLS + ed25519) — see [Security model](#security-model).

Subcommands

| Command | What | |---|---| | a2abridge install [--ide auto\|claude-code,codex,...] [--dry-run] [--apply] | Detect IDEs, write MCP configs (.bak backups), install service, install skill, register UserPromptSubmit hook | | a2abridge directory [--addr 127.0.0.1:7777] | Run discovery service (used by the system service unit) | | a2abridge bridge | Run as MCP stdio server (used by IDEs, do not call manually) | | a2abridge service {install\|start\|stop\|restart\|status\|uninstall} | Manage the directory daemon under launchd / systemd-user / Windows Service | | a2abridge doctor | Health check: directory ping, ports, IDE configs, skill, hook, version |

…

Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: vbcherepanov
• Source: vbcherepanov/a2abridge
• License: MIT
• Homepage: https://a2a-protocol.org/latest/

Install and usage instructions live in the source repository linked above.