What Buzz is in one sentence
Buzz is a self-hostable workspace where humans and AI agents share the same rooms. It feels like a team workspace (channels, threads, direct messages, canvases), but underneath it is a record of signed events.
It's published by Block (Jack Dorsey's company, the one behind Square and Cash App), it's written in Rust, the desktop app runs on Tauri, and the license is Apache 2.0.
The design decision that makes it different
Buzz runs on a Nostr relay. In practice that means one concrete thing: every message, every reaction, every workflow step, every review approval and every git event are the same kind of object, a signed event in a single log.
That gives you the interesting property: there is no structural difference between what a person does and what a process does. The agent signs with its own key, has its own channel memberships and its own audit trail.
That's the part that changes the mental model. In most stacks, an agent is a bot with a service token and app permissions. In Buzz you scope it by identity, the same way you would scope a coworker: you don't give it access to everything and then trust permission flags, you give it the rooms where it belongs.
What an agent can do inside Buzz
It's not just talking in the channel. According to its documentation, an agent has the same surface as a human:
- Open repos and submit patches.
- Review code.
- Run workflows.
- Edit canvases.
- Orchestrate other agents.
- Join voice huddles.
And on the team side, the use cases they describe are genuinely useful:
- Ask the project and get the answer with receipts. The agent searches the history and answers by citing the threads, not by giving an impression.
- Let an agent triage a bug without handing it the keys to the kingdom.
- Turn a branch into a room where the patch, the CI, the review and the merge decision live together, so the channel becomes the record of why that code exists.
- Find the conversation, the patch, the workflow run and the approval in one place, because they are all the same kind of event.
What works today and what doesn't
This is the part of the project I appreciate most, and it's rare to see: its README says explicitly what is ready and what isn't. Here's the summary:
| Works today | Being wired up | Strong opinion, code pending |
|---|---|---|
| Relay, channels, threads, DMs, canvases, media, search, audit log | Mobile clients (iOS and Android, Flutter) | Web-of-trust reputation between relays |
| Desktop app (Tauri + React) | Approval gates in workflows | Push notifications |
buzz-cli (built for agents, JSON in and JSON out) + ACP harness | Huddle lifecycle | Culture features |
| Workflows in YAML (triggers by message, reaction, schedule or webhook) | ||
| Git events (NIP-34: patches, repo announcements, status) | ||
| Git hosting |
They warn about it themselves: don't plan your compliance program around the third column yet.
Where it does NOT compete with OpenClaw or Hermes
This is the most common confusion, and it's worth clearing up because all three get mentioned together.
OpenClaw and Hermes Agent are personal assistants. One for you, running on your machine, helping with your stuff. Buzz is the room where several agents and several people work together. They are different layers of the same stack, not substitutes.
In fact they complement each other: Buzz's ACP harness mentions compatibility with coding agents like Codex and Claude Code. So the agent you already use can be a member of the space, and Buzz provides the coordination, the identity and the record.
What it means for an agency
Let's be honest: today Buzz is for technical teams. If your agency doesn't have someone comfortable standing up a Rust service, it's not your next tool.
That said, there are two reasons to keep it on your radar:
- The problem it attacks is the one you'll have. When you go from one agent to three or four running tasks for clients, the bottleneck stops being the model and becomes knowing who did what, with what permission and with what result. That is exactly the problem Buzz targets.
- The auditable record is a selling point. Being able to show a client the thread where their task ran, who approved it and what changed is worth more than it looks when the client asks what the AI did with their data.
What it isn't
Its own README spells it out, and it's healthy to repeat it:
- It's not blockchain. Signed events work without forcing anyone to buy a coin.
- It's not a plan to replace humans. It works best when people stay in the loop and agents stay in the room.
- It's not finished. And they say so themselves.