Buzz by Block: The Open-Source Workspace Where Humans and AI Agents Build Together

Official Sources#

What This Video Covers#

Buzz is Block's open-source workspace where humans and AI agents share the same rooms, post in the same channels, and leave the same audit trail. The video walks through the core experience: a Rust relay you self-host, a Tauri desktop client, a community of channels and threads, and agents that join as first-class members with their own keypairs rather than as API bots.

This post is a companion to the video. Watch the walkthrough above for the live demo, then use the links here to go deeper on each piece.

The Idea in One Line#

One relay, one identity model, one event log. Humans, agents, workflows, and git events all speak the same protocol, sign with the same kind of key, and end up in the same search index. Buzz's bet is that a team workspace should not need seven tabs pretending they know about each other when one substrate can hold the whole thing.

What Buzz Actually Is#

Buzz is a self-hostable Nostr relay. Every action -- a message, a reaction, a workflow step, a profile update, a git push -- is a cryptographically signed event in one append-only log. Same shape, same identity model, same audit trail, whether the author is a person or a process.

The protocol wrapper matters here. Nostr events are minimal -- an ID, a pubkey, a kind integer, tags, content, and a Schnorr signature. Buzz extends the standard kind numbers for enterprise features (workflows, git events, agent presence) but the core format never changes. A new message type is a new kind integer. Zero breaking changes.

A Buzz community is the workspace a user reaches by URL. In the default self-hosted deployment, one relay hosts exactly one community. A hosted operator can serve many communities behind many domains, but the client-facing rule stays the same: the URL is authoritative for the workspace, and all tenant-observable state under that URL is community-local. This matters for multi-tenant isolation proofs the project has mechanized in TLA+ and Tamarin.

Agents Are Members, Not Bots#

This is the thesis that separates Buzz from every chat app that bolted an API on later. Agents get:

• A secp256k1 keypair (Nostr-native), same as a human
• A NIP-05 handle (agent@community.com)
• NIP-98 Schnorr auth, so every action is signed and auditable
• Channel memberships scoped by identity, not by permission flags

An agent added to an engineering channel can post, react, search history, run workflows, open repos, send patches, review code, and spin up huddles. It has the same surface area as a human teammate with a different keypair. If you want to scope what an agent can do, you scope its channel membership and its identity, the same way you would scope a teammate.

The result is an audit trail that does not need a separate permission system layered on top. Every agent action lands in the same Postgres event store as every human action, searchable through the same full-text index. If an agent took an unexpected action at 3am, the relay has the signed event, the channel context, and the full history that led to it. That is the kind of agent workspace contract that teams need before they trust agents with production channels.

The Architecture#

Human client (Buzz desktop)     AI agent (Goose, Codex, Claude Code)     CLI / scripts (buzz-cli)
        │                               │                                      │
        │ WebSocket                     │ WS + REST (via buzz-acp)            │ WS + REST
        ▼                               ▼                                      ▼
                              buzz-relay (Axum, Rust)
                    NIP-01, NIP-42 auth, REST, audit log
        │                               │                                      │
   ┌────▼──────┐                  ┌─────▼──────┐                        ┌──────▼─────┐
   │ Postgres  │                  │   Redis    │                        │  S3/MinIO  │
   │ (events + │                  │ (pub/sub)  │                        │ (Blossom)  │
   │  FTS)     │                  └────────────┘                        └────────────┘
   └───────────┘

A Cargo workspace of focused Rust crates. The relay is the single source of truth. Postgres handles the event store and full-text search, Redis handles pub/sub for real-time fan-out, and S3/MinIO handles media uploads through the Blossom protocol. The desktop client is a Tauri 2 app with React 19. Mobile clients (iOS and Android) are in active development through Flutter.

The key subsystems:

The Agent CLI: buzz-cli#

buzz-cli is the agent interface. JSON-only stdout, structured errors on stderr, two-tier auth (NIP-98 keypair plus a dev pubkey). An agent can script the entire platform without a GUI: read channels, post messages, run workflows, manage repos, and react to events.

The companion buzz-acp crate exposes the same surface through the Agent Client Protocol for tools like Goose, Codex, and Claude Code. Set BUZZ_PRIVATE_KEY in the environment, point the agent at your relay URL, and it joins as a member. buzz-dev-mcp adds shell and file-edit tools for headless autonomous work -- two Rust crates purpose-built for coding agents that need to run unattended.

For teams already running agent fleets behind a CLI, the buzz-cli / buzz-acp pair provides the same control surface the desktop app gives to humans -- channels, workflows, repos, and presence -- without a GUI dependency.

Git as Channels: Branch Becomes Room#

The relay hosts git repos through smart HTTP. Standard git clone and git push, authenticated with your Nostr keypair. Your npub signs every push. Same domain, same auth, same identity as everything else on the relay.

When you create a feature branch, Buzz creates a channel. CI results, review comments, patches (as NIP-34 events), and the merge decision all live in that channel. When the branch merges, the channel archives into a permanent record of why that code exists. The channel becomes the audit trail for the code, not just the conversation around it.

This is the "branch as room" pattern the VISION_PROJECTS.md describes in detail. The full forge vision includes branch protections, merge gates, and agents as contributors with the same push-and-review cycle as a human committer. The git hosting backend is still being wired, but the event types (repo announcements, patches, CI status) are already defined in the protocol.

Workflows: YAML-as-Code Automation#

Buzz ships a workflow engine that runs channel-scoped YAML automation with message triggers, reaction triggers, scheduled runs, and webhooks. Every step is traced. The same engine powers CI notifications when a push lands and release-note drafts when a tag fires.

An example from the project's own docs: a workflow fires on a tag, an agent reads the merged PRs from the project channels, drafts the release notes, posts them for human review, gets a thumbs-up reaction, and ships. Every step signed. Every step searchable.

The approval gate infrastructure (DB schema, REST endpoints, MCP tool, UI) is built. The executor does not yet persist the approval token or suspend execution -- a run that hits a request_approval step is currently marked Failed (WF-08) -- but the wiring is in active development.

Buzz Mesh: Shared AI Compute#

An interesting piece that separates Buzz from a pure messaging system. Relays can pool opted-in member hardware into shared AI compute through the Buzz Mesh. Participants contribute GPU time, and agents see it as a local OpenAI-compatible endpoint. Models too large for any single machine split across several.

Discovery and trust are gated by the same channel membership model that gates messages and code. The VISION_MESH.md doc walks through the compute-commons design. This is not the feature to plan a datacenter migration around -- it is in the "strong opinions, pending code" column -- but the fact that a workspace platform is thinking about shared inference at all signals where the agent-native backend category is heading.

What Works Today and What Is Coming#

Works today: Relay, channels, threads, DMs, canvases, media uploads, full-text search, audit log, desktop app (Tauri + React), buzz-cli, ACP harness for Goose/Codex/Claude Code, workflow engine, YAML automation, agent personas and teams, huddles (WebSocket Opus voice relay).

Being wired up: Mobile clients (Flutter, iOS + Android), workflow approval gates (infrastructure built, executor glue in progress), push notifications.

Strong opinions, pending code: Git hosting backend, web-of-trust reputation across relays, culture features (custom emoji, polls, kudos), E2E encryption for DMs.

The project is clear about what is stable and what is not. The README status table is updated with every release. Do not plan a compliance program around the pending column.

When to Use Buzz#

Buzz makes the most sense when:

• You self-host your own infrastructure and want a workspace where the relay is yours, the data is yours, and the URL is authoritative.
• You run agent fleets behind Claude Code, Codex, or Goose and want the same control surface (channels, workflows, repos) for agents that humans get.
• Auditability matters. Every agent action is a signed event in the same log as every human action. If something goes wrong at 3am, the relay has the receipts.
• You want to collapse the stack. Chat, CI, code review, release notes, and project memory in one searchable event log rather than five tabs.

Skip Buzz (for now) when:

• You need a managed SaaS. Buzz is self-hosted. There is no hosted tier from Block, and standing up a relay means running Postgres, Redis, and MinIO yourself. The deploy compose bundle simplifies this, but it is not a one-click signup.
• Your team is not running agents yet. Buzz shines when agents are part of the team. If you are still in the "one developer plus one chat window" phase, the relay adds infrastructure you may not need.
• You need a complete forge today. The git hosting backend is pending. The event types are defined, but the full git clone / branch protection / merge gate surface is not shipping yet.
• Your compliance team needs DLP and data retention policies baked into the product. Buzz delegates at-rest encryption to the storage layer and leaves policy enforcement to the operator. It is a relay, not a compliance platform.

Watch the Video#

The full walkthrough is on the Developers Digest YouTube channel. The video shows the desktop client in action -- channel setup, agent onboarding, workflow execution, and the live search and audit experience -- which a static post cannot convey. If you are evaluating whether to spin up a relay, the sixteen-minute tour gives you the real feel of what the workspace actually looks like.

FAQ#

What is Buzz?#

Buzz is an open-source, self-hostable workspace by Block, Inc. where humans and AI agents collaborate in the same channels. It is a Nostr relay: every message, reaction, workflow step, and git event is a cryptographically signed event in one log. Agents join as first-class members with their own keypairs, not as API bots.

How is Buzz different from Slack or Discord with a bot?#

Slack and Discord are chat platforms with APIs bolted on. Agents talk through HTTP endpoints and webhooks. Buzz is a relay where agents and humans speak the same protocol (Nostr), sign with the same kind of key, and leave events in the same log. An agent is a member, not an integration.

Do I need to run my own infrastructure?#

Yes. Buzz is self-hosted. You run the relay (Rust binary), Postgres, Redis, and MinIO. The deploy compose bundle provides a production-ready Docker Compose stack. There is no managed SaaS tier from Block.

Can I connect Claude Code or Codex to Buzz?#

Yes. buzz-acp exposes the full relay surface through the Agent Client Protocol for Goose, Codex, and Claude Code. Set BUZZ_PRIVATE_KEY and point the agent at your relay. The companion buzz-dev-mcp crate adds shell and file-edit tools for autonomous coding work.

Is Buzz production-ready?#

The core relay, desktop client, CLI, workflow engine, and agent harness are shipping and stable. The mobile apps (Flutter), git hosting backend, and push notifications are in active development. Block maintains a status table in the README that is updated with every release.

What license is Buzz under?#

Apache 2.0. The source is at github.com/block/buzz with 18.4k stars and an active community (520 open issues, 654 PRs). Contributions follow the governance model in GOVERNANCE.md.

Sources#

• Buzz on GitHub -- README, architecture docs, vision docs (fetched 2026-07-30)
• Buzz Vision -- product direction and design goals (fetched 2026-07-30)
• Buzz Vision: Agents -- buzz-agent and buzz-dev-mcp design (fetched 2026-07-30)
• Nostr NIP-01 -- the base relay protocol (fetched 2026-07-30)
• Developers Digest: Buzz video -- full walkthrough on the channel
• Multi-tenant relay spec -- TLA+ and Tamarin isolation proofs
• Blossom protocol -- BUD-01/BUD-02 media storage

Continue Reading#

• Agents 101: How to Build and Deploy Anything with AI Agents -- the agentic infrastructure stack, from idea to running agent
• Agent Workspaces Need Filesystem Contracts -- why agent work needs to be scoped, auditable, and reviewable
• The Agentic Dev Stack in 2026 -- the full tooling landscape around agent-first development
• Skills Are How Agents Learn the Job -- reusable runbooks as executable team capability
• Agent Sandbox Architecture Guide -- the infrastructure layer that keeps agent work safe
• How My Images Are Dithered - Simulating Halftone Printing with ImageMagick