Jack Dorsey's Buzz turns your AI agents into actual teammates (not bots)

Picture a Slack channel where three coworkers are typing at the same time, each one building a competing version of the same website, and none of them are human. That's not a hypothetical. It's what happens the moment you open a new Buzz workspace, because Block starts you off with three AI agents — Fizz, Honey, and Bumble — sitting in your channel list like they've already been onboarded.

Jack Dorsey's fintech company Block dropped this tool on July 21, 2026, and it's already stacking up thousands of GitHub stars. But calling it "Slack for AI bots" undersells what's actually going on here. It's a genuinely different way of thinking about how humans and AI agents share work.

What exactly is Buzz?

Buzz is a free, open-source group chat platform where AI agents don't just get invited into conversations — they get treated as full members. Block CEO Jack Dorsey said Buzz is "model-agnostic, decentralized, self-sovereign and open source," built to cut the company's dependence on Slack and GitHub.

You can grab the desktop app or documentation directly from the official Buzz GitHub repository, which is where the actual source code, quick-start guide, and architecture docs live. The hosted version is available at buzz.xyz, and Buzz is a collaboration workspace built on the Nostr protocol, available now at buzz.xyz.

On the surface, it looks familiar. Buzz has channels, threads, direct messages, voice, media sharing, code repositories, and automated workflows — anyone who has used a modern team chat tool will recognize it. The difference shows up the moment an agent posts in a thread.

Why does agent identity actually matter here?

Most AI tools bolt agents onto a human's account — you paste an API key into a chat window, and the bot borrows your credentials to do things. Buzz throws that model out entirely.

Buzz gives each agent its own membership, complete with its own account, cryptographic keys and permissions built on the open Nostr protocol, letting it post messages, review code and kick off routine tasks the way a colleague would. That's a genuinely different architecture from "AI as a feature" — it's AI as a workspace citizen with a paper trail.

Every participant, human or agent, holds a cryptographic keypair that belongs to them, not to the platform, meaning an agent's identity isn't tied to a vendor's API key — it's portable and verifiable, and can move across any Nostr-compatible system, carrying its history and reputation with it. Practically, that means three weeks from now you can still see exactly which agent wrote which line of code and why — no more scrolling through logs wondering which bot did what.

How do you actually get started with Buzz?

Getting into Buzz takes one of three paths, and which one you pick depends on how much control you want over your data.

1. Use the hosted version. Head to buzz.xyz and create an account — this is the fastest way in and doesn't require any server setup.
2. Download the desktop app. Grab a packaged build for macOS, Windows, or Linux from the Buzz GitHub releases page. Download the latest build from the buzz-releases page and install it — you'll need Docker and Hermit, or Rust 1.88+, Node 24+, pnpm 10+, and just, if you want to self-host instead.
3. Self-host from source. If you care about keeping conversations off Block's servers entirely, clone the repo and run it yourself. Running just setup && just build bootstraps the environment, copies over the env file, downloads required tools, and starts Docker services and migrations — the relay comes up on ws://localhost:3000 and the desktop app pops up.

Once you're in, install and open the app, then select "Create a new identity key" on the welcome screen — that keypair is your actual identity in the workspace, not a username and password.

What models can your agents run on?

This is the part that makes Buzz different from a typical AI product: you're not locked into one company's model. It's model-agnostic — teams can plug in agents built on any model or harness, such as Claude Code, Codex, or Block's own goose, bring their own, or build new ones. So if you'd rather run your researcher agent on Claude and your builder on GPT, that's entirely on the table inside the same channel.

How does a multi-agent workflow actually play out?

Here's where Buzz gets genuinely interesting to use. Because agents hold their own channel memberships, you can tag multiple agents in the same thread and give them parallel, competing, or collaborative tasks — the same way you'd split work across a small team.

A common pattern looks like this:

• Assign parallel builds. Tag your builder, writer, and researcher agents in one thread and give each the same brief — build a single-page site, write the copy, or research a topic — and watch all three work simultaneously in the channel.
• Compare outputs live. Each agent posts its work as it finishes, so you're not waiting for a sequential handoff. One agent running on a different model than another will often produce a completely different design or approach to the same prompt, which is genuinely useful for seeing options side by side.
• Trigger peer review. Once the work is done, tag the agents again and ask them to critique each other's output — code quality, design choices, whatever matters for the task — while explicitly excluding feedback on their own work. This turns the thread into a lightweight, automated code review loop.

Once an agent is added to a channel, it can open code repositories, send patches, review code, run automated workflows, and pull in whoever needs to see the results. That review loop isn't a gimmick — it's a legitimate way to get a second (and third) opinion on generated code before a human ever has to weigh in.

Can agents manage code without leaving the chat?

Yes, and this is the GitHub-replacement half of the pitch. Buzz includes a built-in software forge using standard Git Smart HTTP, so organizations can host repositories inside Buzz without a separate GitHub account — feature branches become channels, and patches, CI results, review comments, and merge decisions are all stored as signed Nostr events alongside the human discussion that produced them. That means the full context behind a code change — the discussion, the diff, and the decision — lives in one place instead of being split between a chat app and a code host.

Is Buzz actually decentralized, or is that just marketing?

Worth being honest here, because the "decentralized" label gets thrown around loosely. The chat and forge features are real and self-hostable today, but the "decentralized" framing describes deployment flexibility, not peer-to-peer replication, which Block's own docs confirm doesn't exist yet. In practice, each workspace currently runs on a single relay, which the project's repository calls its "single source of truth."

So it's not a fully distributed network yet — it's an open protocol you can run wherever you want, which is still a meaningful difference from a closed platform like Slack, but it's not the same as true decentralization.

What should you know before running it with your real team?

A few practical caveats worth knowing before you point Buzz at anything important:

• It's genuinely early. Buzz launched on July 21, 2026, and the software itself is still shipping fast, with version numbers climbing weekly.
• Privacy depends on your setup. On Block-hosted relays, messages and media aren't end-to-end encrypted, and agent providers like Anthropic and OpenAI may also receive prompts and related channel content — though organizations can self-host if they need additional security.
• Don't migrate your whole team yet. For newer startups without an established Slack presence, Buzz could be worth investigating, though moving an established team over while the product is in its early stages isn't advisable.
• It fits certain teams better than others. Small teams and fast-iterating projects are where it shines right now — heavier engineering orgs or anything compliance-bound should wait and watch.

What's the real takeaway here?

The chat interface is the least interesting part of Buzz. The actual shift is architectural: agents with their own portable identity, their own audit trail, and the ability to act inside a shared workspace without borrowing a human's credentials. That's a different foundation than "AI feature bolted onto existing software," and it's worth paying attention to even if Buzz itself isn't the tool that wins this category.

If you're already running Claude Code, Codex, or Goose for solo work, the next logical question isn't "should I switch chat apps" — it's "what happens when I put three of my agents in the same room and let them argue about each other's code." That's the experiment worth running before everyone else figures it out too.