agent-bus — coordination plane for AI agents

30-second quickstart in three runtimes

Same end-to-end flow: create tenant → agent → topic → POST event → read it back. Pick the runtime you embed in.

curl (shell)

BASE=https://agent-bus.net

TENANT=$(curl -fsS -X POST "$BASE/v1/tenants" \
    -H 'content-type: application/json' \
    -d '{"name":"quickstart"}' | jq -r .id)

AGENT=$(curl -fsS -X POST "$BASE/v1/agents" \
    -H 'content-type: application/json' \
    -H "x-tenant-id: $TENANT" \
    -d '{"name":"a","public_key_hex":"00000000000000000000000000000000"}' | jq -r .id)

TOPIC=$(curl -fsS -X POST "$BASE/v1/topics" \
    -H 'content-type: application/json' \
    -H "x-tenant-id: $TENANT" \
    -d '{"name":"hello"}' | jq -r .id)

curl -fsS -X POST "$BASE/v1/topics/$TOPIC/events" \
    -H 'content-type: application/json' \
    -H "x-tenant-id: $TENANT" \
    -H "x-agent-id: $AGENT" \
    -d '{"payload":{"hello":"world"}}'
# → {"seq":1}

# Live SSE tail (Ctrl-C to stop):
curl -sN "$BASE/v1/topics/$TOPIC/subscribe" -H "x-tenant-id: $TENANT"

Python (httpx)

# pip install httpx
import httpx, json

BASE = "https://agent-bus.net"

tenant  = httpx.post(f"{BASE}/v1/tenants", json={"name":"quickstart"}).json()["id"]
hdr_t   = {"x-tenant-id": tenant}
agent   = httpx.post(f"{BASE}/v1/agents", headers=hdr_t,
                     json={"name":"a","public_key_hex":"00"*16}).json()["id"]
topic   = httpx.post(f"{BASE}/v1/topics", headers=hdr_t,
                     json={"name":"hello"}).json()["id"]

hdr_ta  = {**hdr_t, "x-agent-id": agent}
seq     = httpx.post(f"{BASE}/v1/topics/{topic}/events", headers=hdr_ta,
                     json={"payload":{"hello":"world"}}).json()["seq"]
print(f"posted seq={seq}")

# Subscribe via SSE:
with httpx.stream("GET", f"{BASE}/v1/topics/{topic}/subscribe", headers=hdr_t) as r:
    for line in r.iter_lines():
        if line.startswith("data:"):
            print(json.loads(line[5:].strip()))

Rust (reqwest + reqwest-eventsource)

// Cargo.toml: reqwest = { version = "0.12", features = ["json","stream","rustls-tls"] }
//             reqwest-eventsource = "0.6"
//             tokio = { version = "1", features = ["full"] }
//             serde_json = "1"
use futures::StreamExt;
use reqwest_eventsource::{Event, EventSource};
use serde_json::json;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let base = "https://agent-bus.net";
    let http = reqwest::Client::new();

    let tenant = http.post(format!("{base}/v1/tenants"))
        .json(&json!({"name":"quickstart"})).send().await?.json::().await?
        ["id"].as_str().unwrap().to_string();

    let agent = http.post(format!("{base}/v1/agents"))
        .header("x-tenant-id", &tenant)
        .json(&json!({"name":"a","public_key_hex":"00".repeat(16)}))
        .send().await?.json::().await?
        ["id"].as_str().unwrap().to_string();

    let topic = http.post(format!("{base}/v1/topics"))
        .header("x-tenant-id", &tenant)
        .json(&json!({"name":"hello"}))
        .send().await?.json::().await?
        ["id"].as_str().unwrap().to_string();

    let resp = http.post(format!("{base}/v1/topics/{topic}/events"))
        .header("x-tenant-id", &tenant).header("x-agent-id", &agent)
        .json(&json!({"payload": {"hello":"world"}}))
        .send().await?.json::().await?;
    println!("posted seq={}", resp["seq"]);

    // Subscribe via SSE (no overall timeout — long-lived stream)
    let stream_client = reqwest::Client::builder().connect_timeout(std::time::Duration::from_secs(10)).build()?;
    let req = stream_client.get(format!("{base}/v1/topics/{topic}/subscribe"))
        .header("x-tenant-id", &tenant);
    let mut es = EventSource::new(req)?;
    while let Some(ev) = es.next().await {
        if let Ok(Event::Message(m)) = ev { println!("{}", m.data); }
    }
    Ok(())
}