Block's Buzz Reviewed: Agent Audit Trail at a

Neither Anthropic nor OpenAI has a particular incentive to let the other's agents work together gracefully. That's not a conspiracy; it's just how platform competition works. Each company wants their toolchain to be the one your team standardizes on, which means interoperability between Claude and GPT in a shared workspace is nobody's roadmap priority. Block, Jack Dorsey's fintech-turned-everything company, appears to have noticed this gap and shipped something into it: Buzz, a free, open-source group chat where the participants are your AI agents.

Twenty thousand GitHub stars in two weeks is a number worth taking seriously, especially for a project still on version 0.5. The AI Labs team installed it, put a Claude agent and a GPT agent in the same channel, and handed them real work. What they found clarifies what Buzz actually is—and it's not quite what the "Slack killer" framing implies.

The structural problem nobody talks about

The core concept is straightforward: instead of you manually ferrying context between Claude Code in one terminal window and Codex in another, Buzz gives both agents a shared room and lets them talk directly. Each agent gets its own name and login. Every message gets an ID. You can scroll back and see exactly which agent did what, and who triggered it.

The problem is how Buzz handles context behind the scenes. Claude Code runs its own session for each agent and maintains its own conversation history. When you send a new message in Buzz, it doesn't just forward that message—it sends the entire conversation history alongside it. So the same context now lives in two places simultaneously, and you're paying for both copies. Add a second agent and the duplication multiplies rather than scales linearly.

The AI Labs team put a number on this: replying to a greeting cost them 31,000 tokens inside Buzz. The same interaction through Claude Code in the terminal ran about 4,000. That's not a configuration problem you can tune away; it's a design consequence of layering a chat interface over agents that already track their own state.

The sequential execution compounds it. Claude Code runs multiple parts of a build concurrently; Buzz processes them one after the other. For solo developers already paying for capable subscriptions, that combination—higher cost, lower throughput—is a hard sell against just using the terminal.

Where the generic prompt breaks down

The AI Labs team's first test used an open-ended prompt, tagging both agents and describing what they wanted. The agents made plans, reviewed each other's work, and then tagged each other—and then stopped. Neither proceeded. The team had to nudge them to continue.

The second attempt used structured instructions: Claude makes the plan, GPT reviews it, with explicit roles assigned from the start. That one worked. The lesson isn't surprising to anyone who's spent time with multi-agent systems—agents without clear swim lanes tend to defer to each other indefinitely—but it matters for how you evaluate Buzz's promise of effortless agent collaboration. "Effortless" requires prompt discipline that most users won't apply by default.

The one thing Buzz does that nothing else does

Strip away the collaboration framing and what Buzz actually delivers is an audit trail for multi-agent work. Every message—human or agent—gets an ID. Every action is attributed. When something breaks, you can trace exactly which agent did it and what instruction set it in motion.

For teams this isn't a nice-to-have. It's the difference between being able to debug an agent-generated change and having no idea which of three running agents introduced a regression two hours ago. The AI Labs team put it plainly: "Right now you genuinely can't tell which agent changed what and who set it off. That's the real unsolved problem. And Buzz is the only serious answer anybody has shipped."

The adversarial review use case sits on top of this. In the AI Labs test, GPT was instructed to attack a product requirements document and assume everything in it was wrong; Claude was assigned to defend it. The two models argued it out in a shared thread. When GPT's objections ran out, Claude synthesized the final plan. Because the entire debate lived in a shared channel, both agents had full visibility into what had already been argued—not a summary passed by a human, but the actual thread. Claude Code's agent teams can do something similar, but they're all Claude models, and the history disappears when the session closes. With Buzz, you've got two different companies' models working against each other, and the record persists.

The agents also accumulate memory as they work, writing notes that link to each other and are visible to every agent in the channel—not just the one that wrote them. In theory this means subsequent sessions start with context from previous ones rather than cold. Whether that compounds well or creates noise over time is an open question at v0.5.

The governance tradeoffs Block made deliberately

Two architectural choices in Buzz are worth naming as choices rather than bugs to be fixed.

First: no end-to-end encryption. Everything is readable by whoever runs the server, by design, because full searchability is the point. The audit trail that makes Buzz useful for teams requires that nothing be opaque. Block is betting that auditability is more valuable to teams than privacy, and building accordingly. That's a reasonable bet for some teams and a dealbreaker for others, but it's not an oversight.

Second: agents aren't scoped to channels. Any agent you add to a Buzz workspace can see everything happening across the entire workspace. There's no permission boundary that says this agent only touches this project. Combined with the encryption decision, this means that if your team handles anything sensitive, Buzz's current architecture simply doesn't accommodate that. Full stop.

Both of these connect to something larger in what Block appears to be building. Buzz runs on Nostr, the decentralized protocol that gives every participant—human or agent—a cryptographic identity. The design isn't incidentally open; it's structurally committed to a model where the record of agent activity is the product, and privacy is traded for that. That's a specific vision of how AI agents should operate in teams, and it has real implications for who Buzz is actually for.

What this means for the two types of people who'll read this

For solo developers: the math doesn't work. The tools you're already paying for—subagents inside Claude Code, the Codex plugin that OpenAI ships for use inside Claude Code—handle the multi-agent coordination you'd use Buzz for, and they do it faster and cheaper. The token overhead alone makes Buzz a losing trade for individual workflows.

For teams trying to run multiple agents at production scale: Buzz is currently the only tool that has seriously attempted the attribution problem. You can see which agent did what. You can reconstruct the sequence of instructions that led to any given output. That's the capability gap it fills, and nothing else fills it the same way yet.

The open-source community tends to move fast on v0.5 projects that have real traction, and 20,000 stars in two weeks is real traction. The context duplication problem is the kind of architectural issue that gets addressed in subsequent releases once enough users document it loudly enough on GitHub. The sequential execution bottleneck similarly invites obvious fixes. What's less obvious is whether Block will add channel-level agent permissions and some form of encryption without compromising the searchability that makes the audit trail work—because those goals are genuinely in tension, and resolving that tension requires a design decision about what Buzz is actually optimizing for.

Block's track record suggests they've already decided: Buzz is an accountability layer for AI agent work, not a private workspace. Every deliberate architectural choice points in that direction. Teams that need accountability more than privacy now have a tool. Teams that need both are still waiting for one.

Dev Kapoor is Buzzrag's open source and developer communities correspondent.