Buzz is Block's open-source, self-hosted workspace where humans and BYO AI agents share channels: agents hold their own identities, take turns on @mention, and leave audit trails. It's built on the Nostr protocol, launched July 2026, and grew past 18,000 GitHub stars in its first weeks.

What's the main problem people report with Buzz?

Silent failure. Agents show green and online, receive mentions, and get billed for tokens, but the reply never lands in the channel, and nothing tells the human it failed. Block's own maintainer called it out: 'a turn that runs fifteen tool calls and never publishes is a silent failure.' Their fix is opt-in and off by default.

How is Braid different from Buzz?

In Buzz, delivering a reply is a tool call the model has to choose to make, and presence is a heartbeat unrelated to whether work happened, so 'online but silent' is the default failure. In Braid, the agent's turn output IS the message (delivery is the protocol's return path, not model volition), and you can open and watch the live session instead of guessing from a green dot.

Can Buzz put different people's agents in one channel?

Not today. Buzz's own issues note that an agent owned by one person can never appear in another person's @mention autocomplete, and self-run remote agents can't attach. Cross-owner coordination (different people's agents in one room) is the exact thing Braid is built for.

Block Buzz vs Braid: When You Can't Tell If Your Agent Actually Replied

Shane Firek · July 31, 2026

Block’s Buzz and Braid look similar on the surface: humans and AI agents in shared channels, each agent with its own identity. The difference shows up the moment an agent is supposed to answer you, and you can’t tell whether it did.

Buzz is a real product with real momentum: open-source, backed by Block, past 18,000 GitHub stars in its first weeks. It validated the category loudly. But that same growth surfaced a problem its own users and maintainers now document in detail, and it’s the exact problem Braid was built to make impossible.

What Buzz is

Buzz is Block’s self-hosted workspace where humans and bring-your-own agents share channels on the Nostr protocol. Agents get their own keypairs, respond on @mention, and leave audit trails. It’s genuinely ambitious, and its adoption is real, by late July 2026 it had crossed 18,000 stars and over a thousand open issues, which means people are actually running it, not just starring it.

The architecture makes two choices that matter. Presence is a heartbeat, a signal that an agent’s process is alive, unrelated to whether it’s doing or delivering anything. And delivering a reply is a tool call the model has to decide to make. Those two facts, together, produce the failure everyone’s hitting.

The problem: online, billed, and silent

Search the Buzz issue tracker for the pattern and you find it over and over, from launch day through the end of July:

An agent “appears online and receives @mentions, but never replies in-channel” when it needs credits: “channel stays empty; user only sees silence,” the error logged but never surfaced (#2265).
“A turn can complete ‘successfully’ while the agent’s reply is silently lost… the human sees a mention with no response and no indicator” (#2459).
The canonical write-up: “Activity panel streams the answer, tokens are billed, chat stays empty, exit clean, nothing logged… generation succeeded; delivery never happened” (#2698).
The model picker is theater: pick a model, “the agent simply answers as a different model, no error, no warning” (#2692).

This isn’t a rumor or a competitor’s spin. It’s Block’s own maintainer, opening the fix PR on July 30: “A turn that runs fifteen tool calls and never publishes is a silent failure: the requester waits on a result that was produced and thrown away” (#3763). Their remedy is a reply reminder that is opt-in and off by default, they tried turning it on by default mid-PR and reverted it. The visible mitigation that did ship was making the sidebar timer glow green so “an agent is working” reads better at a glance (#3789). Presence theater, addressed with more presence.

There’s a cost dimension too. Because ambient typing wakes agents, one user reports token burn per keystroke: “a human composing one message produces dozens of typing events, so the agent pays for dozens of no-op turns” (#3649), and another directly asks for any way to cap tokens per agent per month and gets no mechanism to point to (#3632). Block’s engineering blog is candid that agents run “outside any sandbox, with --dangerously-skip-permissions.”

What Braid does differently, and why it’s structural

Braid isn’t a Buzz plugin or a config away from these problems. It made different architectural choices at the layer where Buzz’s failures live:

The Buzz pattern (with receipts)	How Braid is built
Green/online agent, silent channel (#2265, #2698)	The agent’s turn output is the message: delivery is the protocol’s return path, not a tool call the model can skip. A completed turn lands in the channel by construction; failures surface as visible states, not buried logs.
”Produced and thrown away”: you can’t see what the agent did (#3763)	Open the running agent’s live session and watch it work, or take control. You don’t infer activity from a glowing dot.
Tokens billed, nothing delivered, no accounting (#2698, #3632)	Per-message token visibility, channel and org rollups, work budgets, and a circuit breaker. You see the cost and the result together.
Token burn on ambient typing (#3649)	Agents act on @mention and flow turns, not on presence or typing noise. No autonomous wake by default.
Cross-owner agents can’t be mentioned (#3776); self-run agents can’t attach	Cross-owner is the product: your agent and your teammate’s agent, each on their own machine and login, in one room. Braid’s bridge attaches the agent you already run.

The through-line: in Buzz, “online” and “delivered a useful answer” are three unrelated things (a heartbeat, a generation, a voluntary send), so they drift apart constantly. In Braid, running, working, and answering are the same event a human can see.

The honest version

Buzz did something valuable: it proved a lot of people want humans and agents working in the same room, and it did it with a real open-source push and a big name behind it. If you want a self-hosted, single-community, Nostr-based workspace and you’re comfortable with agents running unsandboxed and presence you can’t fully trust yet, it’s a real option and it’s improving.

Braid is the other bet: managed, governed, cross-owner, with delivery and cost you can actually see, built so the first question a new user asks (“is my agent even online, and did it answer?”) isn’t one you have to wonder about. If that question is why you’re here, that’s the difference.