Verdict: Buzz, launched by Block on July 21, 2026, is the first open-source workspace that treats AI agents as first-class teammates with their own cryptographic identities — not bots bolted onto a chat tool. It is Apache-2.0, self-hostable, model-agnostic, and free at launch. For teams already running coding agents like Claude Code or Codex, Buzz is worth piloting now, even though it is candidly unfinished ("rough edges and giant chasms," per Block's own engineering blog). The strongest reasons to try it: your agents keep their own signed audit trail, you can switch underlying models without losing channel context, and a community-pooled local-compute feature means some agent work runs without a per-token API bill.
Last verified: 2026-07-31 · License: Apache 2.0 · Price: Free (hosted and self-hosted, early beta) · Built on: Nostr · GitHub stars: ~14.7K (July 28, 2026)
TL;DR
- Buzz is a Slack-style workspace where AI agents join channels as members, with their own keypairs, not borrowed bot tokens.
- It works with Claude Code, Codex, and Block's own Goose via the Agent Client Protocol (ACP); you can swap the underlying model or harness without losing conversation history.
- A "shared compute" feature (Buzz Mesh) lets community members pool local open-weight models, so some agent work runs with no API key and no per-token cost.
- Block's hosted version at buzz.xyz is free in early beta; self-hosting is free on your own infrastructure (Docker + Postgres + Redis + MinIO).
- It is early-stage software — do not migrate your whole team yet. Pilot it with one agent in one channel first.
What Is Buzz by Block, and How Is It Different From Slack?
Buzz is a self-hostable, channel-driven workspace where humans and AI agents collaborate in the same rooms, built on the Nostr open protocol. Block introduced it on July 21, 2026, describing it as "model-agnostic, decentralized, self-sovereign, and open source" (Block announcement). The code is published under an Apache-2.0 license at the block/buzz GitHub repository.
The core difference from Slack is how agents are treated. In Slack, an AI agent is an app integration that borrows a bot token and acts behind a permission-flagged wrapper. In Buzz, an agent is a member — it holds its own cryptographic Nostr keypair, the same identity model a human uses, and signs its own messages, reviews, and code patches with that key. Block's engineering blog, written by Tyler Longwell, frames the problem directly: traditional setups are "letting bots play dress-up as us" by handing agents human credentials (Block Engineering Blog).
| Dimension | Slack + bot integration | Buzz agent member |
|---|---|---|
| Identity | Shared app/bot token | Own cryptographic keypair |
| Permissions | App-scoped permission flags | Channel membership (like a human) |
| Audit trail | Opaque side effects | Same signed event log as humans |
| Model switch | Replace bot, lose session | Swap harness/model, keep context |
| Revocation | Revoke the bot token | Revoke the agent's key, keep humans intact |
| Self-hostable | No | Yes (Apache 2.0) |
Who Built Buzz and Why?
Buzz was built by Block, Inc. — Jack Dorsey's company behind Square, Cash App, Afterpay, Tidal, and Bitkey. Dorsey announced the platform on X, calling the launch an effort to reduce Block's own dependence on outside collaboration tools.
The origin story is practical, not aspirational. Block had built an internal Slack-integrated agent called BuilderBot. It worked, but the team concluded Slack was not architecturally designed for multi-agent collaboration: shared bot credentials, awkward model switching across teams, and credential management all piled up. Longwell summarized the lesson on the engineering blog: "The bottleneck moved from intelligence to coordination. That is a workspace problem. So we built Buzz." (Block Engineering Blog). Coordination, not intelligence, is also the problem we tackle in our guide to orchestrating AI agents like a company.
Block also maintains Goose, the open-source agent framework that Buzz supports as a first-class runtime.
Which Agent Runtimes Does Buzz Support?
Buzz is agent-agnostic. Any agent speaking the Agent Client Protocol (ACP) can join a community. The supported runtimes fall into three tiers in the desktop app:
| Tier | Runtime | What it is |
|---|---|---|
| 1 (built-in installer) | Goose, Claude Code, Codex, Buzz Agent | Auto-installs and auth probes |
| 2 (preset, PATH-probed) | Hermes Agent, OpenClaw, Cursor, OpenCode, Amp, Kimi Code, Grok Build, Oh My Pi | Static list, not editable |
| 3 (user-defined) | Any ACP-speaking binary | Custom JSON in your app-data folder |
A critical detail for teams already paying for Claude or OpenAI: Buzz lets you point the agent at a model you already have access to. If you have a Claude subscription, your agent can use it. You are not forced into per-token API billing just to run an agent in a Buzz channel — though the adapter you choose determines what credentials you need (Claude Code needs an ANTHROPIC_API_KEY; Codex needs OPENAI_API_KEY, not a ChatGPT subscription, per the remoteopenclaw.com setup guide). For a deeper comparison of routing Claude Code through alternative harnesses and what it actually costs, see our walkthrough of how to run Kimi K3 inside Claude Code. Goose is the lowest-friction default because Block builds both sides of that integration; buzz-acp with no config spawns goose acp natively.
Block's own buzz-agent runtime supports Anthropic, OpenAI-compatible, and Databricks providers and performs a context handoff — summarising its own history and continuing — when the window fills.
How to Get Started With Buzz: Three Paths
Path 1 — The Hosted Version (Fastest)
- Go to buzz.xyz and sign up. This is Block's managed deployment — no infrastructure on your side.
- Create a community and a first project channel.
- Add an agent the same way you'd add a human teammate.
- Pin the agent to a harness (Goose is the default) and a model.
Block's hosted relays are free at launch, which Bradley Axen — Block's Head of AI Capabilities — calls a beta. Block has not published usage limits or a pricing roadmap for hosted relays yet (The New Stack). The site itself is candid about maturity, inviting you to "come test the early stages."
Path 2 — The Desktop App
Packaged releases live on the GitHub releases page:
| Platform | Package |
|---|---|
| macOS | .dmg |
| Linux | .AppImage or .deb |
| Windows | .exe (needs Git Bash, or set BUZZ_SHELL to a bash-compatible shell) |
By default the app connects to ws://localhost:3000. To point it at a relay you control or one someone shared with you, set BUZZ_RELAY_URL before launching, or switch relay from inside the app. There is also an Android app on Google Play (xyz.block.buzz.mobile); no iOS App Store listing had appeared as of July 28, 2026.
Path 3 — Self-Host From Source
This is the "your infrastructure, your rules" path — the one that makes Buzz interesting to teams that would never put internal code discussions on someone else's servers. Requirements, per the README:
git clone https://github.com/block/buzz.git && cd buzz
. ./bin/activate-hermit
just setup && just build
just dev # starts the relay + desktop app
just dev brings up the full local stack: the Rust relay, PostgreSQL, Redis, and MinIO for media storage. Required tooling: Docker plus either the bundled Hermit toolchain or Rust 1.88+, Node 24+, and pnpm 10+. For a production single-node or VPS deployment, Block ships a production Compose bundle in deploy/compose/ (docker compose + Postgres, Redis, MinIO, optional Caddy/TLS).
Budget real engineering time for a production deployment — you are operating a database, a cache, object storage, and a WebSocket relay, plus wiring in your existing git remotes and identity story. That is the honest cost of the $0 price tag on this path.
How Do Agents Actually Join a Buzz Channel?
Setting up a Buzz agent comes down to three decisions: identity, instructions, and harness.
1. Mint the agent's keypair first
Each agent needs its own Nostr keypair, and that keypair is the identity — not an API token bolted onto a bot account. Run buzz-admin generate-key, which prints a public and secret key pair. The README is blunt: "Save the secret key immediately — it is not stored and cannot be recovered." Register the public key as a relay member (a kind:13534 membership event) so the agent can read and publish. Mint a separate keypair per agent.
That is what makes the audit trail real rather than cosmetic: actions are signed by the agent's own key and scoped by channel membership — "scoped by identity, not by permission flags" (remoteopenclaw.com).
2. Write the agent's instructions (system prompt)
Behaviour comes from the agent's instructions, layered on top of a base prompt rather than replacing it. Block's buzz-agent runtime exposes this via BUZZ_AGENT_SYSTEM_PROMPT or BUZZ_AGENT_SYSTEM_PROMPT_FILE. In the desktop app it is a form field, not an env var.
A practical split: pin your "doer" agent to a frontier model for hard work, and pin a second agent to a cheaper, faster model for triage, summarisation, and brainstorming. Both agents live in the same channels and see the same history.
3. Pick the harness and model
Setting BUZZ_ACP_AGENT_COMMAND="claude-agent-acp" and running buzz-acp spawns Claude Code. Switching the harness or model afterward does not erase the conversation, because durable context lives in the channel as signed relay events — not inside the harness process. Move a Claude Code agent to Codex and the new runtime still reads the same threads and the same search index through the Buzz CLI.
What Is Buzz Shared Compute (and Why Does It Matter)?
Buzz shared compute — the repo calls it Buzz Mesh — is the feature that makes Buzz genuinely different from any other agent platform. It lets one community member's machine serve a locally running open-weight language model to other members of the same community, so agents in the community can run on pooled hardware instead of a paid API.
Block's design document describes it this way: "the idle GPUs scattered across your community become one pool, usable by every agent in the community, gated by the membership you already have" (VISION_MESH.md).
How to enable it:
- Open Settings → select Compute
- Choose a suggested model under Share compute
- Turn sharing on, and wait until the card reports "sharing" (not downloading/preparing/starting)
- On the Agents screen, "Buzz shared compute" appears as a default LLM provider
- Agents with no pinned provider inherit that default — no API key, no per-token bill
Two properties make this work:
- Admission gate = membership gate. Because Buzz is a Nostr relay, it already maintains a cryptographic membership list. Non-members cannot find the mesh, join it, serve to it, or use it.
- The relay coordinates trust, not traffic. MeshLLM carries inference over direct QUIC or encrypted relays. The Buzz relay never carries the prompt. Your prompts go to a peer's machine, not a vendor's server.
This is a cost and privacy trade-off, not a free upgrade. The runbook's proof model is a quantized Qwen 4B on 16 GB Apple Silicon — a competent small model, not a frontier one. Sub-1B models can prove inference is reachable while still failing an agent's long prompt and required tool call. Use shared compute for high-volume, low-stakes work: summarising channels, triaging notifications, watching repositories. Use a frontier API harness for multi-file refactors.
| Dimension | Cloud harness (Claude Code/Codex) | Buzz shared compute |
|---|---|---|
| Cost model | Per-token API or paid seat | No per-token bill; cost = hardware + electricity |
| Speed | Fast, consistent, always on | Variable, depends on member machine |
| Model ceiling | Frontier models, large context | Quantized open-weights sized to hardware |
| Privacy | Prompts leave for vendor | Prompts run on member-owned hardware |
| Setup effort | Install harness, add API key, done | Install Buzz, enable sharing, download a model |
How Swarm Orchestration Works in Buzz
Block's engineering blog describes something more ambitious than one agent per channel — multiple agents coordinating as a swarm:
"I often have one frontier agent driving a swarm of cheaper, faster agents. The smart one keeps the big picture in context. The fast ones research, build, test, and review in parallel." — Tyler Longwell, Block Engineering Blog
In practice this looks like:
- Agents communicate via ordinary @-mentions, injected into active work instantly
- Agents self-organize: recruiting each other, splitting work into side channels, handing tasks across contexts
- Humans redirect work in real-time instead of waiting for completed (potentially wrong) output
- Visible history preserves failed paths and the reasoning behind final decisions
Longwell's framing of why this matters is sharp: "Search auth refresh six months later and find the report, rejected fix, patch, review, and final call. A conventional forge preserves the diff and a green check. Buzz also preserves why the obvious fix was wrong."
If the self-organizing swarm pattern resonates, our longer dive into building a skill-centric AI agent harness covers the same idea from the harness side — how a swarm of agents keep one conversation alive without losing state between tools. And for teams that want durable task routing across many agents, the autonomous AI agent task board walkthrough maps naturally onto the Buzz channel-as-room model.
What About Security and Privacy?
Buzz's identity model is the security story. Every participant, human or agent, holds a Nostr keypair that belongs to them, not to the platform. Block chose Nostr specifically because it "solves the most fundamental problem in multi-agent collaboration: identity" (Block announcement). Each message, reaction, workflow step, review approval, and git event is recorded as a single signed event in one log, producing a hash-chain audit trail that applies whether the author is a person or a process.
Security properties from the engineering blog:
- Leaked agent key → revoke the agent without replacing the human's identity
- Remove the owner → the agent cannot reconnect
- Immediate risk → terminate active sessions
- Server sees routing metadata only, not encrypted payloads
- Live telemetry/cancellation uses ephemeral encrypted messages; memory/cost records are encrypted but durable
One open question flagged in the launch discussion: multi-channel agents need carefully designed rules to avoid crossing permission boundaries between channels. Buzz's answer is identity scoping — each agent acts under narrowly-scoped authorization signed by its owner, and its access can be revoked individually. This class of problem is young across the whole industry, so treat the model as a sound foundation, not a finished guarantee. For frameworks that address the same governance question across a portfolio of agents, see our guide to AI agent sprawl and governance in 2026.
How Does Buzz Compare to the Alternatives?
| Feature | Buzz | Slack + bot agents | Notion Custom Agents |
|---|---|---|---|
| Agents as first-class members | Yes, own keypair | No, bots on tokens | Connected to workspace |
| Open source / self-hostable | Yes (Apache 2.0) | No | No |
| Bring-your-own model/harness | Yes (any ACP agent) | Limited to vendor apps | Limited to Notion's providers |
| Signed audit trail across chat + code | Yes (Nostr events) | No | Partial |
| Bundled Git hosting | Early (NIP-34) | Links out | Links out |
| Switch model without losing context | Yes | No | N/A |
| Shared compute pooling | Yes (Buzz Mesh) | No | No |
| Maturity | Days old, early beta | 10+ years | Mature |
A different integration route exists: Notion introduced its Developer Platform in May 2026 to connect external agents inside Notion workspaces, and by May customers had created more than one million custom agents. Notion extends an installed product rather than replacing it. Buzz asks teams to adopt a separate workspace — which is the right shape if your team wants code, chat, and agents in one signed record, and the wrong shape if you just want agents wired into tools you already use.
What This Means for You
For small teams and builders already running coding agents: Buzz is the cheapest, most open way to put your agents in a shared room with your teammates today. The hosted path costs nothing and takes minutes. Wire in Goose (zero-config default) or Claude Code (set one env var), give an agent a real task in one channel, and see whether the audit trail and context-persistence hold up for your workflow.
For larger teams with established Slack and GitHub footprints: Do not migrate yet. Buzz is candidly unfinished — mobile clients, push notifications, approval gates, and enterprise controls (SSO, compliance exports, retention policies) are not documented publicly. Use Buzz as a parallel pilot for one agent-heavy project while your production collaboration stays where it is.
For teams that care about data sovereignty: Buzz is the only option here that lets you own the relay. Self-hosting means your messages, code, and agent audit trail never have to touch anyone else's servers. The operational cost is real — you are running Postgres, Redis, object storage, and a WebSocket relay — but the architecture is built for it.
For everyone: the architecture is ahead of the maturity. Treat Buzz as a pilot platform, re-check the GitHub repo before committing to any UI detail (it moves fast), and calibrate expectations against Block's own words: "Come test the early stages with us."
FAQ
Q: Is Buzz free to use? A: Yes, as of July 28, 2026. The code is Apache 2.0, Block's hosted version at buzz.xyz is free in early beta, and self-hosting is free on your own infrastructure (Docker + Postgres + Redis + MinIO). Block has not published usage limits or paid tiers yet — treat free as a launch-phase fact, not a permanent promise.
Q: Can I use Claude Code as a Buzz agent?
A: Yes. Claude Code connects through the claude-agent-acp adapter, which wraps the Claude Agent SDK in an ACP interface. Set ANTHROPIC_API_KEY and BUZZ_ACP_AGENT_COMMAND=claude-agent-acp, then run buzz-acp. In Buzz Desktop, Claude is one of four tier-1 runtimes with a built-in installer and auth probe.
Q: Is Buzz a blockchain or crypto product? A: No. Buzz is built on Nostr, a lightweight open protocol for cryptographically signed, relayed messages. It uses keypairs for identity but has no token, chain, or cryptographic assets.
Q: Can I swap the underlying model without losing the conversation? A: Yes. Durable context lives in the channel as signed Nostr relay events, not inside the harness process. Change the harness or model and the new runtime still reads the same threads and the same search index through the Buzz CLI. This falls out of the architecture rather than being bolted on.
Q: What is Buzz shared compute and is it fast enough for real work? A: Buzz Mesh lets community members pool local open-weight models, so agents in the community run on pooled hardware instead of a paid API. It is a cost and privacy trade-off, not a free upgrade: the proof model is a quantized Qwen 4B on 16 GB Apple Silicon. Use it for high-volume, low-stakes work (summarising, triaging, watching repos), not multi-file refactors.
Q: Does Buzz work on mobile?
A: Android, yes — on Google Play (xyz.block.buzz.mobile). No iOS App Store listing had appeared as of July 28, 2026; the README lists the Flutter mobile clients as "being wired up."
Q: Is Buzz ready for production? A: Block itself says it is "useful today" with "rough edges and giant chasms," and the site invites you to "come test the early stages." Hosted Block relays have no published SLAs, usage limits, or enterprise controls (SSO, compliance exports, retention). Pilot it for one agent-heavy project first; do not migrate your whole team yet.
Discussion
0 comments