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/blobsand 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: [email protected]. Security disclosures: [email protected].