Buzz

Scope and currency

This is an architecture evaluation, not a deployment diary. In August 2026 we reviewed the official Buzz README and ARCHITECTURE.md—positioning, screenshots, maturity table, crate map, and known limitations. We have not run Buzz in production. Release binaries, Railway one-click, and Compose requirements change; confirm current docs and your team’s ops capacity before planning a migration. Editorial review: 2026-08-10.

Contrast with our Ankik notes (self-hosted Postgres): those are lived ops. This page is “what the design implies.” Same posture as Agentic Inbox—repo-backed architecture review, not a usage claim.

What it is

Buzz is an open-source (Apache 2.0) self-hostable workspace from Block, Inc. (GitHub repository: github.com/block/buzz) where humans and AI agents share the same rooms. Under the hood it is a Nostr relay: every message, reaction, workflow step, review approval, and git event is a signed event in one log—same identity model and audit trail whether the author is a person or a process.

A Buzz community is the workspace selected by URL. Single-relay self-host: one relay URL ≈ one community. Hosted multi-tenant operators can map many domains, but tenant-visible state stays community-local.

In product terms it aims at the sprawl teams fake with chat + forge + bots + CI dashboards + release tools + search: one substrate instead of seven tabs that do not know about each other. Agents are members with their own keys and channel membership—not haunted cron jobs in a side panel.

People and agents building together in the same room (official README screenshot).

A look inside (official screenshots)

Agents are members, not bots. Add an agent to a channel the same way you add a person.

Spin up a room in seconds. Name it, describe it, make it private.

Media you can talk about. Leave comments pinned to specific frames.

Architecture (official shape)

Clients:  Human desktop (Tauri + React)  ·  AI agents (Goose, Codex, Claude Code via buzz-acp)  ·  buzz-cli
                │                                    │                                      │
                └──────────── WebSocket / REST ──────┴──────────────────────────────────────┘
                                             ▼
                                      buzz-relay (Axum)
                         NIP-01 · NIP-42 auth · channel/DM/media/workflow/git · audit
                         │                      │                    │
                    Postgres               Redis                S3 / MinIO
                 (events + FTS)         (pub/sub)              (Blossom media)

Single source of truth: the relay. Clients do not gossip peer-to-peer; they connect to one relay that verifies signatures, persists events, fans out to subscribers, indexes search, and triggers automation.

Stack (from repo)

Layer	Choices
Protocol	Nostr NIP-01 wire format; Schnorr-signed events; kind-based dispatch
Relay	Rust workspace (buzz-relay on Axum); Postgres, Redis, S3/MinIO
Desktop	Tauri + React
Agents	buzz-cli (JSON in / JSON out) · buzz-acp (ACP harness for Goose / Codex / Claude Code)
Automation	YAML workflows: message / reaction / schedule / webhook triggers
Git	NIP-34 patches, repo announcements, status; git hosting backend
Mobile	Flutter clients listed as in progress (not “works today”)

Features that matter for a stack decision

• One event log for chat, agents, workflows, and git — search and audit over the same substrate
• Agents as first-class members — own keypairs, channel membership, and audit trail (scoped like teammates)
• buzz-cli agent surface — designed for LLM tool calls (JSON in / out), not only human chat UX
• YAML workflows — message, reaction, schedule, webhook; approval gates exist in infra but are still being wired end-to-end (upstream maturity table)
• Self-host posture — Docker Compose / production Compose under deploy/compose/; packaged desktop builds; optional Railway relay deploy
• Honest maturity table — README separates ✅ works today vs 🚧 being wired vs 💭 opinions pending code

Maturity snapshot (upstream README, review window)

✅ Works today	🚧 Being wired up	💭 Strong opinions, pending code
Relay, channels, threads, DMs, canvases, media, search, audit log	Mobile (iOS + Android, Flutter)	Web-of-trust reputation across relays
Desktop app (Tauri + React)	Workflow approval gates (infra exists, glue drying)	Push notifications
buzz-cli + ACP harness	Huddle lifecycle events	Culture features
YAML workflows (message / reaction / schedule / webhook)
Git events (NIP-34) + git hosting backend

ARCHITECTURE.md also lists concrete gaps (e.g. rate-limiter trait not enforced in production path; some workflow actions / approval resume not fully wired). Treat 💭 and “known limitations” as non-negotiable reading before compliance or migration planning.

Cost breakdown

Path	Reference cost	What you get
Buzz self-host	VM + Postgres + Redis + object storage; your ops time	Full relay, desktop clients, agent CLI/ACP surface; community-local state you own
Railway one-click relay (upstream path)	Hosting bill on Railway + your config	Relay without racking a VPS yourself; still not “managed Slack”
Slack (managed chat)	Pro from ~$8.75/user/mo (public list pricing; confirm current)	Managed chat, ecosystem, zero relay ops—agents usually as bots with separate identity models
Discord + bots	Free tier / Nitro / bot hosting	Lightweight communities; weak product-engineering audit story

There is no published SaaS seat price for “Buzz Cloud” in the OSS README we reviewed: the product is self-host / operator-run. Invoice savings vs Slack only matter if someone owns upgrades, backups, identity, and incidents—same total-cost lens as open-source evaluation.

The Good

• Humans and agents in one room — not a chat product with a bot API bolted on; agents sign events like people
• One log, one search, one audit story — messages, patches, workflow steps, and approvals share protocol shape
• Serious engineering surface — Rust monorepo, NIP-42 auth, hash-chain audit, Postgres FTS, explicit crate boundaries
• Agent-first CLI — buzz-cli JSON I/O is a clearer integration path for automation than scraping a web UI
• Honest docs — maturity columns and ARCHITECTURE “known limitations” reduce surprise vs hype-only AI workspaces
• Credible Block OSS — Apache 2.0, governance/security docs, vision papers for sovereign / forge / agents

The Bad — what to know before adopting

1. This is a platform, not a plugin. You are adopting a relay + desktop + (optional) agents + Postgres/Redis/object storage. Ops surface is closer to self-hosting a product than flipping a Slack app switch.
2. Not finished—and they say so. Mobile incomplete; workflow approval gates and some actions still drying; push / multi-relay reputation are future. Do not plan compliance programs on the 💭 column.
3. Protocol lock-in is real. Nostr kinds, keypairs, and Buzz custom ranges are powerful; they are not “export to Slack JSON and forget.” Migration risk is cultural and technical.
4. Identity model is cryptographic, not Google SSO-first. NIP-42 / Schnorr keys and channel membership—great for agent parity; different onboarding than Workspace or Microsoft 365.
5. Desktop-first today. Packaged builds for macOS / Linux / Windows; Windows agent shell expects Git Bash. Browser-only teams or pure mobile-first orgs will feel the gap until Flutter clients mature.
6. Rate limiting and some automation paths are incomplete per ARCHITECTURE.md at review time—design targets exist without full production enforcement.

When to use / When to skip

Use Buzz if:

• You want humans and coding agents in the same channels with shared audit and search
• Self-hosting a Rust relay + Compose stack is acceptable (or Railway/operator path fits)
• You care about signed event history for decisions (incident memory, branch-as-room, release workflows)
• Your team can live desktop-first while mobile catches up
• You are evaluating agent workspace architecture even if you never migrate off Slack (strong reference)

Skip if:

• You need managed chat SLAs, enterprise SSO polish, and zero infra ownership tomorrow—stay on Slack/Teams
• Nobody will run Postgres backups, Redis, object storage, and relay upgrades
• Mobile-first field teams or non-technical orgs need polished apps day one
• You only need a thin bot in existing Slack—Buzz is a workspace replacement thesis, not a /remind clone
• Compliance depends on features still marked pending or unwired

Prerequisites (official path)

• Try the app: packaged builds from GitHub Releases (macOS Apple Silicon / Intel, Linux AppImage/deb, Windows x64—unsigned Windows may hit SmartScreen)
• Self-host / dev: Docker + Hermit (or Rust 1.88+, Node 24+, pnpm 10+, just)
• Agents: BUZZ_PRIVATE_KEY + buzz-cli; ACP for Goose / Codex / Claude Code
• Windows agents: Git for Windows (Git Bash) or BUZZ_SHELL pointing at a bash-compatible shell
• Production single-node: deploy/compose/ (Postgres, Redis, MinIO, optional Caddy/TLS)—root docker-compose.yml is day-to-day dev only

Setup checklist (official path)

1. Clone and toolchain — git clone https://github.com/block/buzz.git && cd buzz then . ./bin/activate-hermit

2. Bootstrap — just setup && just build (copies .env.example if needed, Hermit tools, Docker services + migrations)

3. Daily dev — just dev (relay + desktop); relay default ws://localhost:3000

4. Split terminals (optional) — just relay + just desktop-dev

5. Agents — set keys; use buzz-cli / ACP harness rather than scraping the UI

6. Hosted relay (optional) — To run a relay for your team without managing servers, you can deploy one to Railway in a click:

   

   See also the Block engineering write-up.

Our recommendation

Apply the same Keep / Configure / Replace / Build lens as every ReframeHub note (start with the Stack Decision Checklist if you want a self-serve pass).

• As a tool to run today: credible for engineering teams who already self-host serious infra, want agent-as-member semantics, and accept an evolving surface (desktop + relay first). Not a casual Slack replacement for the whole company next Monday.
• As a reference architecture: one of the strongest open blueprints we have seen for signed, searchable human+agent collaboration on a single event log—worth reading even if you Keep Slack and only steal ideas (channel-as-branch, workflow events, agent keypairs).
• If you need managed chat with zero relay ops: Keep Slack/Teams/Discord; add agents as integrations carefully. We would not push a full Buzz cutover solely to “have AI in chat.”

Need help choosing managed chat + bots vs a self-hosted agent workspace? Book a Reframe audit for Buzz / collab stack ($199). For a lighter platform self-host lesson on Cloudflare, see Agentic Inbox; for the general self-host checklist, see open-source evaluation.