Block’s Buzz is the rare AI workspace pitch that starts with own the relay, not rent another SaaS tab. Humans and agents share the same rooms. Every action — message, reaction, workflow step, review thumbs-up, git patch — is a signed Nostr event in one community log. Agents get their own keypairs, not a haunted bot token.
The public repo (block/buzz) is Apache 2.0, Rust-heavy, with a Tauri desktop client and an agent-first CLI. Desktop hit v0.4.24 in mid-July 2026; the project sits in the multi-thousand-star range on GitHub with active relay work (including recent smart-HTTP git fixes). This post is the explainx.ai map: what Buzz is, what actually works, how it fits the agent harness era, and when you should (or should not) self-host it.
TL;DR — What People Are Asking
| Question | Answer |
|---|---|
| What is it? | Self-hostable humans + agents workspace on a Nostr relay |
| Who builds it? | Block, Inc. · Apache 2.0 |
| Identity? | Same key model for people and processes |
| Agents? | Members with own keys + channel scope + audit trail |
| Clients? | Desktop (Tauri) · buzz-cli · ACP (Goose / Codex / Claude Code) |
| Backend? | buzz-relay + Postgres + Redis + S3/MinIO |
| Git? | NIP-34 patches / announcements / status + hosting backend |
| Mobile? | Flutter iOS/Android — being wired |
| Blockchain? | No — signed events, not coins |
| Try fast? | Release .dmg / AppImage / .exe or just dev |
What Buzz Is Betting On
Most teams fake “agent collaboration” with seven tabs: chat, forge, bots, CI dashboards, release tools, search, and glue. Buzz’s bet is one community / one identity model / one event log so those surfaces stop pretending they know about each other.
A community is the workspace you reach by URL. In the single-relay setup that ships today, the relay URL selects exactly one community. Hosted multi-tenant operators can put many communities behind many domains, but the client rule stays: the URL is authoritative, and tenant-observable state under that URL is community-local.
That sounds abstract until you use the three stories from the README:
- Incident memory — 2am “have we seen this error?” An agent searches months of history, posts threads with receipts, offers to page the last shipper. Evidence stays in-channel.
- Branch as room — Feature branch opens a channel. Patches arrive as NIP-34 events, CI posts, agent first-pass review, humans react, merge decision lands beside the evidence.
- Release that writes itself — Tag fires a YAML workflow. Agent drafts notes from merged work, waits for 👍, ships. Every step signed and searchable.
If that reminds you of loop engineering and harness design, good — Buzz is trying to be the shared room those loops currently lack.
Agents as Members, Not Bots
The README line that matters: Agents are members, not bots. Add an agent to a channel the same way you add a person.
Practical consequences:
| Slack-era bot | Buzz agent member |
|---|---|
| Shared app token | Own keypair |
| Permission flags | Channel membership like a human |
| Opaque cron side effects | Same event log as humans |
| “Bot said so” | Searchable, signed audit trail |
Scoped by identity is how you let an agent triage a bug without handing it the kingdom. That is closer to how you’d onboard a contractor than to how most MCP/chat plugins work — and it pairs with the industry lesson from OpenClaw / agent safety debates: blast radius belongs in identity and room membership, not vibes.
Agents can open repos, send patches, review code, run workflows, edit canvases, orchestrate other agents, join voice huddles (lifecycle still drying), create channels, and pull people in — same surface area as humans, different key.
Works Today vs Being Wired vs Vision Fog
Honesty table (paraphrased from upstream):
| ✅ Works today | 🚧 Being wired | 💭 Strong opinions, pending code |
|---|---|---|
| Relay, channels, threads, DMs, canvases, media, search, audit | Mobile (iOS + Android, Flutter) | Web-of-trust reputation across relays |
| Desktop (Tauri + React) | Workflow approval gates (infra exists, glue drying) | Push notifications |
buzz-cli + ACP harness (Goose, Codex, Claude Code) | Huddle lifecycle events | Culture features |
| YAML workflows (message / reaction / schedule / webhook) | ||
| Git events (NIP-34) + git hosting backend |
Upstream’s warning is correct: do not plan compliance programs around the 💭 column. Read VISION.md and friends as direction, not SOC2 evidence.
For harness shoppers comparing closed and open stacks, put Buzz next to our top agent harnesses 2026 list as a workspace substrate, not as a drop-in replacement for Claude Code’s local loop.
Architecture in One Diagram’s Worth of Prose
Clients: human Desktop, AI agents via buzz-acp (ACP ↔ MCP bridge), and scripts via buzz-cli.
All talk WebSocket / REST to buzz-relay (NIP-01, NIP-42 auth, channel/DM/media/workflow/git REST, audit log).
Persistence: Postgres (events + FTS), Redis (pub/sub, presence), S3/MinIO (Blossom media).
Notable crates (from the README map): buzz-core, buzz-relay, buzz-cli, buzz-acp, buzz-agent, buzz-workflow, buzz-dev-mcp (shell + file edit), git-sign helpers, admin and E2E tooling. Multi-community mode scopes tenant-observable rows and audit chains by host-derived community while sharing infra — important if you are evaluating hosted multi-tenant vs one-box self-host.
Recent relay work includes gzip decompression for git smart-HTTP bodies and lease-gated push pipelines — the kind of boring infra that tells you Block is serious about git-in-the-relay, not only chat skins.
Getting Started Paths
Packaged Desktop — Grab the latest release build for macOS / Linux / Windows. Default relay ws://localhost:3000; override with BUZZ_RELAY_URL or in-app relay switch.
Block employees — Use the internal squareup/buzz-releases build (pre-wired relay/provider). Do not confuse that with the public OSS release.
From source:
git clone https://github.com/block/buzz.git && cd buzz
. ./bin/activate-hermit
just setup && just build
just dev # relay + desktop
Needs Docker + Hermit (or Rust 1.88+, Node 24+, pnpm 10+, just). Agents: set BUZZ_PRIVATE_KEY and drive buzz-cli JSON in / JSON out. Windows agents need Git Bash (or BUZZ_SHELL pointing at a bash-compatible shell).
That agent-first CLI shape is the same instinct behind other JSON harnesses we cover — see Pi minimal harness and Claude Code loops for adjacent patterns.
How Buzz Fits the 2026 Agent Stack
| Layer | Typical tool | Buzz’s angle |
|---|---|---|
| Model | Opus / Sonnet / open weights | Bring your own via ACP agents |
| Harness | Claude Code, Codex, Goose | buzz-acp plugs them into the room |
| Memory | Chat scrolls, Notion, tickets | One signed log + FTS |
| Git | Forge PRs | NIP-34 + hosting in-community |
| Automation | Cron + Zapier | YAML workflows on message/reaction/schedule/webhook |
| Trust | Bot permissions | Identity-scoped membership |
Buzz does not replace your model. It replaces the glue that currently loses the “why we merged” story across tabs. If you already run multi-agent economics experiments (Cursor swarm), a shared room with receipts is the missing product surface.
When Self-Hosting Makes Sense
Good fit
- You want agents in the same audit trail as humans
- You can run Docker Compose / Postgres / Redis / object storage
- Desktop-first engineering teams are fine while mobile catches up
- You care about sovereign / self-hosted control (read
VISION_SOVEREIGN.mdupstream)
Wait or pilot narrowly
- You need production push + polished iOS/Android tomorrow
- Compliance wants finished approval-gate UX (infra ≠ product glue)
- Your org cannot operate a relay (then you need a hosted operator, not a laptop demo)
- You only wanted “ChatGPT in Slack” — Buzz is more substrate than chatbot
Also remember security culture: local agents that can shell and edit files need the same discipline as Cowork sandbox lessons — membership scoping helps, it does not remove kernel or tool risk.
Honest Limitations
- Mobile and some workflow/huddle pieces are unfinished.
- Vision docs outpace shipping code by design — treat 💭 as R&D.
- Self-host ops cost is real (Postgres backups, Redis, S3, upgrades).
- Windows agent shell depends on bash availability.
- “Agents orchestrate agents” needs careful channel design or you recreate bot spam with better cryptography.
- Not a substitute for a mature forge if your org’s compliance is GitHub-Enterprise-shaped today — use Buzz as complementary room + event log while git hosting matures in your threat model.
Bottom Line
Buzz is Block shipping a serious answer to “how do humans and agents share a workspace without seven fake integrations?” Own the relay. Sign the events. Give agents keypairs. Desktop + buzz-cli + ACP + NIP-34 git are enough to pilot a branch-as-room workflow this week; mobile and polish are catching up.
If your agent strategy is stuck in chat bots and permission flags, clone the repo, run just dev, and put one coding agent in a private channel with a real bug. The receipts — or the gaps — will teach you faster than another slide deck.
Related on explainx.ai
- India orders GitHub to block Bitchat (July 24) — Bluetooth mesh messenger vs I4C public-order order; not the same as Buzz
- What is an agent harness?
- Top 10 open & closed agent harnesses 2026
- Pi — minimal agent harness
- Claude Code loops — official guide
- Cursor agent swarm economics
- Is OpenClaw safe?
- Loop engineering for coding agents
- Context / prompt / loop harness stack
- Claude Cowork SharedRoot — agent sandbox risk
Sources: block/buzz README · ARCHITECTURE.md / VISION*.md in-repo · GitHub Releases (Buzz Desktop) · Apache-2.0 LICENSE
Feature maturity reflects the public block/buzz README and release cadence as of July 24, 2026. Mobile, approval-gate glue, and vision-column items change quickly — re-check the works-today table before committing production incident response to Buzz.