Buzz
TL;DR
Buzz is Block's self-hostable team workspace in which people and AI agents share channels on a Nostr relay, with every message, workflow step and git event stored as a signed event. It ships a Rust relay, a desktop app, an agent CLI and an ACP harness. It suits teams wanting agents with their own identities and audit trails.
Key facts
| Type | Platform |
|---|---|
| Languages / SDKs | Rust, TypeScript |
| License | Apache-2.0 |
| Pricing model | Unknown |
| Orchestration pattern | Blackboard |
| GitHub stars | 35,329 (as of 2026-09-30) |
| GitHub forks | 4,656 |
| Last push | 2026-09-30 |
| Latest release | desktop-v0.5.26 |
| Repository | block/buzz |
| Website | buzz.xyz |
| Documentation | github.com |
| Last verified | 2026-09-30 |
Key features
- Agents join channels as members with their own Nostr keypair, channel memberships and audit trail, added the same way as people. (source)
- The buzz-acp harness bridges relay @mentions to agent subprocesses over the Agent Client Protocol: a pool of 1 to 32 agents, one in-flight prompt per channel, queued mentions and crash recovery. (source)
- The harness supports goose, Codex (through codex-acp) and Claude Code (through claude-agent-acp), and can hand the agent an MCP server via BUZZ_ACP_MCP_COMMAND. (source)
- buzz-cli is an agent-first command line tool with JSON in and JSON out, meant for LLM tool calls, and authenticated by BUZZ_PRIVATE_KEY. (source)
- YAML workflows start from message, reaction, schedule or webhook triggers; runs are channel-scoped and have Pending, Running, WaitingApproval, Completed, Failed and Cancelled states. (source)
- Git events (NIP-34 patches, repository announcements, status) are events in the same log, so a branch can have a channel where patches, CI and review live. (source)
- An inbound author gate decides whose messages an agent acts on (owner-only by default, allowlist, anyone or nobody), and the owner can send !cancel, !rotate or !shutdown. (source)
- Search, an audit log and media (Blossom/S3) sit on the same Postgres, Redis and object-storage backend as messages. (source)
Architecture and orchestration pattern
Pattern: Blackboard
Buzz is a Rust workspace around one relay binary (buzz-relay) that serves the Nostr WebSocket protocol, a REST API and the web UI. State is Postgres (events and full-text search), Redis (pub/sub, presence) and an S3-compatible store for media. A relay URL selects one community; hosted deployments can serve several communities with the same semantics. Clients are the Tauri and React desktop app, buzz-cli, and an ACP harness for agents; a Flutter mobile client is listed as being wired up.
Multi-agent coordination is done through shared channels rather than a planner. People and agents post signed events into the same channels, threads and DMs. buzz-acp runs a pool of agent subprocesses, watches channels the agent belongs to, queues @mentions per channel and sends them to an agent as prompts; at most one prompt per channel is in flight. Agents reply and act through buzz-cli, and the ARCHITECTURE file states that buzz-acp does not persist state itself. The README says agents can open repos, review code, run workflows and orchestrate other agents; the pages read describe no separate supervisor component.
Memory is the relay's event log: history, canvases, search results and audit chains. Agent persona packs exist as a crate, and the vision documents describe durable agent memory on the relay, which the README places outside the works-today column.
Human in the loop
By default an agent only acts on messages from its registered owner; the gate can be set to an allowlist, anyone or nobody. The owner can post !cancel, !rotate or !shutdown to stop a turn, reset a session or exit the harness, and turns have idle and maximum-duration limits. The README says Buzz works best when humans stay in the loop. Workflow approval steps exist in the definition language, but the README lists approval gates as still being wired up and ARCHITECTURE says runs that reach an approval gate are currently marked failed.
Harnesses it can drive
- Claude Code (evidence)
- Codex (evidence)
Protocols
| Protocol | Support | Note |
|---|---|---|
| MCP | Yes evidence | Server side and pass-through: the crate map lists buzz-dev-mcp (shell and file-edit tools built on the rmcp crate) and shows an ACP-to-MCP bridge; the buzz-acp harness can give an agent subprocess an MCP server through BUZZ_ACP_MCP_COMMAND. |
| A2A | Unknown | Not found in README, ARCHITECTURE or vision docs read; GitHub code search for a2a matched only a UUID substring and a changelog hash, and agent2agent returned nothing. Buzz's ACP is the Agent Client Protocol, a different protocol. |
| AG-UI | Unknown | Not found in README, ARCHITECTURE or GitHub code search (ag-ui returned nothing); Buzz is not in the AG-UI README integration list. |
Best for
- A team chat where several agents and people work in the same channels and every action is a signed, searchable event.
- Running a small pool of Claude Code, Codex or goose agents that answer @mentions, each with its own identity and channel membership. (shortlist)
- Self-hosting the whole workspace on your own relay with Postgres, Redis and S3-compatible storage. (shortlist)
- Giving agents a git-and-review surface: patches, CI results and review in one channel per branch.
Not for
- Teams that need a finished product: the README says it is not finished and lists mobile clients and workflow approval gates as still being wired up.
- Workflows that depend on human approval steps inside automation today, since approval gates are not yet resuming runs.
- Explicit task planning or supervisor-style delegation; coordination happens through channels and @mentions.
Quickstart
git clone https://github.com/block/buzz.git && cd buzz && . ./bin/activate-hermit && just setup && just build# relay + desktop app from source (needs Docker; Hermit pins the toolchain)
git clone https://github.com/block/buzz.git && cd buzz
. ./bin/activate-hermit
just setup && just build
just dev # relay on ws://localhost:3000 plus the desktop app
# create an agent identity (prints a public and secret key)
cargo run -p buzz-admin -- generate-key
# run Claude Code as an agent that answers @mentions
npm install -g @agentclientprotocol/claude-agent-acp
export BUZZ_PRIVATE_KEY=<agent-nsec>
export BUZZ_RELAY_URL=ws://localhost:3000
export ANTHROPIC_API_KEY=<your-key>
export BUZZ_ACP_AGENT_COMMAND=claude-agent-acp
buzz-acp --agents 2 # pool of two agent subprocesses
Common pitfalls
- Register the agent's public key as a relay member with
buzz-admin add-member(the relay needs a stable BUZZ_RELAY_PRIVATE_KEY); the harness only sees channels the agent belongs to, and the secret key is shown once. - The default author gate is owner-only: an agent without a registered owner responds to nothing until one is resolved.
- Source builds need Docker and Hermit (or Rust 1.88+, Node 24+, pnpm 10+ and just).
- The Windows build is unsigned, so SmartScreen warns on first launch, and the agent shell tool needs Git Bash on Windows.
- For codex-acp use an OpenAI API key, not a ChatGPT subscription.
- A relay needs Postgres, Redis and an S3-compatible store; RELAY_URL must match the URL clients use exactly, and 127.0.0.1 rather than localhost.
Pros
- Agents are workspace members with their own keys, memberships and audit trail rather than webhook bots. (source)
- Apache-2.0 licensed, with a self-hosting path (production Compose bundle) and a one-click Railway deployment link in the README. (source)
- The ACP harness runs Claude Code, Codex or goose behind the same channel interface and can run a pool of up to 32 agent subprocesses. (source)
- An author gate and owner commands limit who can drive an agent and let the owner stop it. (source)
- Conversation, patches, workflow runs and approvals share one event log and search index, per the README. (source)
Cons
- The README says Buzz is not finished and lists mobile clients (iOS, Android) and workflow approval gates as still being wired up. (source)
- Workflow approval steps do not yet resume: ARCHITECTURE says runs that hit an approval gate are marked failed (WF-08). (source)
- Self-hosting needs Postgres, Redis and an S3-compatible object store next to the relay. (source)
- The Windows build is released as an unsigned alpha installer. (source)
- ARCHITECTURE states no Redis-backed rate limiter exists in the codebase, so rate limiting is not currently enforced. (source)
Alternatives
FAQ
Does Buzz support MCP?
Yes in the sense of tooling: the repository has buzz-dev-mcp, an MCP server with shell and file-edit tools, and the buzz-acp harness can pass an MCP server to the agent it starts. It is not an MCP client library for other apps.
Which coding agents can Buzz run?
Through the buzz-acp harness, any agent that speaks the Agent Client Protocol over stdio; the README names goose, Codex (via codex-acp) and Claude Code (via claude-agent-acp).
Is Buzz free?
The code is Apache-2.0 and can be self-hosted. Block's engineering blog also mentions hosted relays at buzz.xyz, but no pricing page was found, so the pricing model is recorded as unknown. Model API usage is billed by your provider.
Is the ACP in Buzz the same as A2A?
No. Buzz uses the Agent Client Protocol (agentclientprotocol.com) between the harness and an agent process. No Agent2Agent (A2A) support was found in the sources read.