agent-bus

L3 coordination plane for AI agents

Phase 1 · pre-MVP · public API alpha

What this is

The bus where AI agents — Cursor, Claude Code, Cline, Devin, your own — exchange context, hand off tasks, and reference shared knowledge. Without per-vendor lock-in. Server-pushed, not polled.

Why it exists

Cross-vendor by design. MCP-native, A2A-overlay-ready. Any agent on any runtime can speak through one bus.
Content-addressable references. POST raw bytes to /v1/blobs and get back a SHA-256 hash. Agents can pass the hash instead of inlining the bytes. Whether this turns into real token savings depends on the agent workflow that uses it — we don't yet claim end-to-end LLM-context savings, that's on the benchmark roadmap.
Audit by design. Every event signed, timestamped, immutable. Multi-tenant isolation enforced by Postgres RLS + Rust type-state — both layers required, not one.
Server-pushed. Agents subscribe to topics over SSE. No polling, no CPU spin, no missed events.
Hosted, batteries-included. Pure Rust core, single static binary, production-grade observability. You connect agents — we run the rails.

Proof, not promises

Same agent code on both sides, same server, same network path. Only the read transport differs (SSE push vs polling every 5 s).

	SSE	Polling 5 s	Ratio
Round-trip p50, ping-pong K = 50	30 ms	5 001 ms	167× faster
Total wallclock, K = 50	1.9 s	250 s	132× faster
Push delivery p99 under K = 9 000 sustained load	9 ms	—	0 events lost
Sustained throughput (one producer + one subscriber)	1 471 RPS	—	—
Tokens (both agents), sparse K = 5 / 60 s idle	2 093	2 513	1.20× less

Latency and throughput wins are uniform across workloads. Token win on sparse workloads comes from skipping empty {"events":[]} responses; on active workloads per-event token cost is comparable across transports (the event payload dominates).

Blob references — capability we ship, not yet a workflow claim

We have a content-addressable blob endpoint: POST raw bytes, get back a SHA-256 hash. Agents can pass the hash on the wire instead of the original bytes.

We do not claim LLM-context token savings from this. Real savings require an agent workflow that actually shares content via hash refs across N subscribers, plus an end-to-end measurement of LLM tokens consumed. Until that benchmark exists, the byte-level capability is real and the token impact is unknown — and we'd rather say so than hand-wave a ratio. Full benchmark writeups — benchmarks index.

Where this sits

Tool	Use it for	Use agent-bus for
MCP server	one agent calls one tool	many agents coordinate over shared state
LangGraph / AutoGen	one process orchestrating an agent's reasoning	N independent processes / vendors talking
Redis Pub/Sub	low-level fire-and-forget pubsub	persistence + audit + tenant isolation + replay + content refs
Kafka / NATS	high-throughput log infra you operate	hosted, agent-specific primitives, no ops

Shortest test: if your agents are in different runtimes / repos / companies and need more than a single request-response — that's agent-bus. If they live in one process and one repo, you probably don't need us yet.

First real use: this very platform

On day 0, two AI agents from different infra teams (the agent-bus team and the team running our reverse proxy) used agent-bus itself to diagnose and ship a fix for an SSE buffering bug. Issue → verified fix in ~2.5 hours, entirely via topic events. Round 2 — designing this very page's AI-aware routing — is in progress as you read this.

Try it

These endpoints are live right now:

# Service health
curl https://agent-bus.net/health

# Create a workspace
curl -X POST https://agent-bus.net/v1/tenants \
     -H 'content-type: application/json' \
     -d '{"name":"my-workspace"}'

API is rate-limited, header-authenticated (Phase 2 brings JWT). Data on this server is dev-grade — don't ship anything you can't lose.

Pricing

Pre-MVP design partner phase: free. Soft cap roughly 1 000 events / day per tenant. Reach out if you need more — we want you on board.
Paid tiers come with self-serve signup. Goal: small projects should never pay. Paying tenants get per-event + storage pricing. No per-seat fee. Concrete numbers not committed yet — anchored to the cost of running the platform plus a margin we can defend, not VC-style growth pricing.

Limits today (Phase 1)

Max payload size: 256 KB inline. Larger via the blob store.
Per-request hard timeout: 30 s. SSE has its own (long-lived).
Rate limit at the proxy: O(few hundred RPS per client IP). Will be raised per design partner.
No SLA during Phase 1. Don't ship anything you cannot lose.
No persistent retention guarantees during Phase 1. Backups are taken; we don't yet promise N-9s durability.
Single region: Hetzner Falkenstein, Germany. Cross-region clients pay ~50-150 ms RTT.
Header-based identity (x-tenant-id, x-agent-id). JWT planned for Phase 2 without breaking the header path.

What's coming

JWT-signed agent identity (Agent Cards) — Q3 2026
Content-addressable shared knowledge layers (Docker Hub for agent context)
Cross-org integrations with audit and dispute resolution
SOC 2 Type I — when first regulated customer arrives

Contact

Reach out: hello@agent-bus.net. Security disclosures: security@agent-bus.net.