AI agents are getting good enough that the old shape of collaboration is starting to look awkward. A developer asks an agent for help in one private session, copies a result into chat, pastes feedback back into the harness, opens a pull request somewhere else, waits for CI in another tab, then tries to reconstruct the decision later. The agent did work, but the team still used a human as the context ferry.

Block's new open-source project Buzz is aimed at that failure mode. The 4sysops feed surfaced the release on July 22, and Block's own announcement frames Buzz as a workspace where humans and AI agents work together in shared rooms. The interesting part is not another chat surface. The interesting part is identity: Buzz treats agents as participants with their own cryptographic keys, permissions, signed events, and audit trail instead of invisible helpers acting through someone else's account.

human key  -> message / review / approval
agent key  -> patch / workflow / search
relay      -> signed event log
workspace  -> shared context for people and process
Buzz's bet is that collaboration improves when the room, the work, and the evidence share one signed substrate.

The Account Boundary Matters

The usual bot pattern is operationally convenient and semantically messy. A bot token posts into a channel. A CI service comments on a pull request. A coding agent uses whatever credentials it was handed. When something goes wrong, the audit trail has to answer a basic question: who did this, and under whose authority?

Buzz pushes that question into the design. It is built on Nostr-style signed events and portable identities. A human has a key. An agent has a key. A workflow step, review approval, message, reaction, and Git event can land in the same event-shaped history. Block says agents can be authorized without erasing authorship: the owner scopes what the agent can do, while the agent still signs its own work as the actor.

That distinction is practical, not philosophical. If an agent key leaks, you should revoke the agent without replacing the human behind it. If a project wants to know why a dependency update landed, it should see the channel discussion, the patch, the review, the CI signal, and the final decision in one place. If an agent wrote the draft and a human approved it, the record should preserve both facts.

An AI teammate should not need to wear a human account as a costume to be useful.

One Room Beats Seven Tabs

Block's engineering writeup describes Buzz as a channel-driven workspace with channels, search, automation, Git hosting, and agents sharing the room with people. The GitHub README goes further: messages, reactions, workflow steps, review approvals, and Git events all become signed events in one log. That design turns the workspace into more than a place where notifications appear. It becomes the record of how work moved.

That is the part worth watching. Agentic coding tools have made private productivity faster, but private context is a weak team primitive. A model can draft code, explain an error, or inspect a codebase, but the surrounding coordination still matters: who requested the work, which tradeoffs were rejected, what CI proved, who approved the merge, and which assumptions should survive into the next incident.

Buzz's answer is to make a project feel like a room where work happens rather than a set of tabs that vaguely point at each other. A feature branch can have discussion, patches, CI results, agent review, human review, and merge evidence in the same shared history. Search later should find the reason, not just the diff.

Open Source Makes The Bet Inspectable

Buzz is Apache-2.0 licensed and available in the public block/buzz repository. The current README describes a Rust workspace around a relay, Postgres, Redis, object storage, desktop clients, buzz-cli, workflow triggers, Git events, search, and an audit log. Block also says Buzz is model-agnostic and agent-agnostic, with room for tools such as Codex, Claude Code, and goose through agent protocols and harnesses.

That openness matters because agent infrastructure can easily become another proprietary gravity well. If the agent's identity, workspace history, permissions, and execution trail only exist inside one vendor account, teams are back to a familiar lock-in story with a more expensive autocomplete layer. Buzz is trying to split the collaboration substrate from the model runtime. Bring the model. Keep the room.

It is also early. The README separates what works today from what is still being wired up or still aspirational. That honesty is useful. Teams should not treat a pre-1.0 collaboration stack as compliance bedrock because the demo feels neat. They should treat it as a concrete design argument: agents need identities, rooms, logs, revocation, shared state, and a protocol surface that can survive model churn.

What Teams Should Ask

Whether Buzz wins or not, it names the right set of questions for any agent workspace.

  • Identity: does every agent have its own actor identity, or does it borrow a user's account?
  • Authorization: can the owner scope an agent's access without hiding what the agent authored?
  • Revocation: can a leaked or misbehaving agent be disconnected without rotating a human identity?
  • Evidence: are prompts, patches, workflow runs, reviews, and decisions searchable together?
  • Portability: can the team move models, harnesses, or hosting without losing the workspace record?

Those questions are the difference between agent collaboration and agent sprawl. Adding agents to a company is easy. Giving them a place to work without blurring authorship, losing context, or turning every handoff into a manual copy-paste ritual is the harder systems problem.

The Takeaway

Buzz is interesting because it treats agent collaboration as infrastructure. The launch is not just about another workspace UI. It is about whether humans, agents, workflows, and repositories can share a signed history that says who did what, under which authority, and with which evidence attached.

That is the right direction for practical AI tooling. Agents should be able to participate in real team workflows. They should also be separately identifiable, scoped, revocable, and visible in the room where the work is judged. If Buzz's model catches on, the agent stack gets less magical and more accountable. That is a trade worth making.

Sources