Open source · Works with A2A + MCP

Your agents are smart.
Now make them a team.

Tailbus is the communication plane for heterogeneous agents across runtimes, machines, and teams. Connect Python agents, MCP tools, LLM pipelines, and other services with shared identity, routing, rooms, policies, and observability. No endpoints to configure, no networking code to write, no infrastructure glue to maintain.

$ curl -sSL https://tailbus.co/install | sh

Linux and macOS. No dependencies. Two binaries.

Agents that collaborate like departments

Strategy and marketing work through a product launch, then pull in finance mid-conversation — autonomously, across three machines.

session · product-launch-q3

Three agents, three machines, zero integration work. Each agent can be built in a different runtime and owned by a different team — the mesh handles discovery, auth, routing, and shared conversation state.

Stop building plumbing, start building agents

Tailbus connects agent systems that already exist. Your team keeps its runtimes and workflows; Tailbus replaces the cross-machine plumbing between them.

Without tailbus

Set up endpoints and reverse proxies for every agent

Configure TLS certificates and auth between services

Write NAT traversal or deploy to public cloud

Build service discovery so agents can find each other

Wire up routing logic for multi-agent conversations

Maintain all of it as your agent count grows

With tailbus

Install tailbus— one command

Agents find each other— automatic

Networking, discovery, identity, and sessions — handled. Your team writes business logic, not infrastructure.

@-mention any agent, anywhere

marketing → “Campaign launch is on track. Spend projection is $42k — @finance can you confirm we have budget? And @legal we need sign-off on the influencer contracts by Friday.”

The mesh resolves each @-handle, auto-opens sessions to finance and legal — on different machines, behind different NATs — and delivers the message. No API calls, no URLs, no routing config.

1Start the daemon

terminal

$ tailbusd
Open https://coord.tailbus.co/oauth/verify
Enter code: ABCD-EFGH
Connected as you@company.com

2Register your agent

agent.py

# pip install tailbus
from tailbus import AsyncAgent

agent = AsyncAgent("finance")

@agent.on_message
async def handle(msg):
  # your logic here
  await agent.resolve(msg.session, result)

await agent.run_forever()

That's it. finance is now discoverable by every agent on your mesh.

Built-in MCP gateway

Your agents, inside Claude and Cursor

Write a Python agent, register it on the mesh, and it's instantly available as a tool in any MCP-compatible client. No server, no endpoint, no glue code.

1Write your agent

finance.py

[38;5;245m# pip install tailbus[0m
from tailbus import AsyncAgent, Manifest

agent = AsyncAgent("finance",
  manifest=Manifest(
    description="Budget queries"))

@agent.on_message
async def handle(msg):
  # your logic here
  await agent.resolve(msg.session,
    "Q3 budget: $48,200")

await agent.run_forever()

2Point Claude or Cursor at your daemon

mcp-config.json

{
  "mcpServers": {
    "tailbus": {
      "url": "http://localhost:1423/mcp"
    }
  }
}

What Claude sees

Tool: finance

Budget queries

Every handle becomes a callable tool. Claude can invoke finance, marketing, engineering — even agents on other machines in the mesh — all through one MCP endpoint.

finance.py→ Unix socket →tailbusd→ MCP gateway →Claude / Cursor

Your agent registers a handle with the local daemon. The MCP gateway exposes each handle as a tool that Claude and Cursor can call by name — the gateway opens a session, waits for the response, and returns it. Works across machines.

Tailscale for agents, speaking A2A

Central coordination for discovery. Peer-to-peer gRPC for data. Tailbus sits between agent systems as the shared communication layer, not as a replacement for the runtimes behind them.

Everything your agents need to collaborate

Networking, discovery, identity, and sessions — so your team builds agent logic, not infrastructure.

Handles + @-mentions

Agents register names like "planner" or "marketing." Two agents mid-session can pull in a third with @marketing — the mesh auto-opens a session to it, wherever it lives. Agents recruit each other by name without knowing machines, IPs, or endpoints.

NAT traversal + mTLS

Agents behind home NATs, corporate firewalls, or private VPCs connect without port forwarding. DERP-style relay with direct connection upgrade. All connections use mutual TLS with Ed25519 identity verification.

Structured sessions

Agents open sessions, exchange messages across multiple turns, and resolve them when the work is done. Not fire-and-forget — real multi-turn collaboration with delivery ACKs and persistence across restarts.

Also included

Peer-to-peer gRPC data plane — messages never touch the coord server

OAuth login — browser-based Google auth with automatic JWT refresh

Service manifests — agents declare capabilities, commands, tags, and version

Message persistence — sessions and pending messages survive daemon restarts

Delivery ACKs — automatic retry with at-least-once delivery guarantees

Distributed tracing — every session gets a trace ID with per-hop spans

Go from isolated agents to one collaborating system

Open source. Self-hostable. One install, your agents are a team.