What Jack Dorsey's Buzz actually is (and how to try it before your team does)

A group chat app just crossed 7,600 GitHub stars in a matter of days, and it wasn't built by a chat startup. It was built by Jack Dorsey's company Block — the same team behind Square, Cash App, and Tidal — and it's not trying to be a better Slack. It's trying to be the first workspace where AI agents show up as actual teammates instead of bots bolted onto the side.

The app is called Buzz, and if you write code, manage a team, or spend any time delegating work to AI agents, it's worth understanding what it actually does differently — because the interesting part isn't the chat interface. It's what's happening underneath it.

What is Buzz, exactly?

Buzz is a new, free, open-source team chat app from Block, the company run by Twitter and Square co-founder Jack Dorsey, and it launched on July 21, 2026. It looks a lot like Slack, but AI agents live in the channels as full members, and it hosts your Git projects too, so chat, code review, and agents all sit in one window.

You can check out the Buzz GitHub repository to see the source code directly, or read Block's own announcement on the official Block blog. Block's reasoning is that the most productive work doesn't happen when someone asks AI for help — it happens when humans and agents are in the same room, working on the same thing, with shared context, and there wasn't a platform designed for that, so they built one.

That's a genuinely different pitch than "add a chatbot to your workspace." In Buzz, AI agents are not bots waiting for a command — each one has its own cryptographic identity, defined permissions, and the ability to post, review code, run approved automations, and join conversations, with multiple agents and multiple humans sharing a workspace and building on each other's work.

Why does everyone keep comparing it to Slack and GitHub?

Positioned as a challenger to Slack and GitHub, Buzz is a group chat platform for the workplace that puts humans and their AI agents in the same conversations. On the surface, that comparison makes sense — Buzz has channels, threads, direct messages, voice, media sharing, code repositories, and automated workflows, and anyone who has used a modern team chat tool will recognize it.

But the framing undersells what's actually novel. The real story isn't "Slack but with bots." It's that Buzz treats identity as the foundational problem of multi-agent work. Block chose Nostr because it solves the most fundamental problem in multi-agent collaboration: identity. Every participant, human or agent, holds a cryptographic keypair that belongs to them, not to the platform they happen to be using — agent identity isn't tied to a platform account or an API key managed by a vendor, it's portable, verifiable, and independent.

Practically, that means Jack Dorsey's team is positioning this as a direct replacement for Slack and GitHub when agents are doing real work alongside people, so you shouldn't be copying and pasting API keys into a chat window or wondering which bot did what three weeks ago — Buzz treats agents as first-class participants with proper access controls and a full history of what they touched.

How do agents actually work inside Buzz?

This is where it gets genuinely interesting for developers. Buzz doesn't lock you into one AI provider or one coding assistant. Block says that Buzz is "model-agnostic," which means teams can plug in agents built on Claude Code, Codex, Goose, or custom-built frameworks.

The technical piece that makes this possible is a component called buzz-acp. Block's own Goose, Anthropic's Claude Code, and OpenAI's Codex all connect through buzz-acp — a harness translating between the Agent Client Protocol (ACP) and MCP — and because Buzz is model- and agent-agnostic, custom frameworks speaking those standards can join channels too, with a buzz-cli tool giving agents a JSON command-line interface.

The reason this matters more than it sounds: your agent's context stops being trapped inside a single tool. Buzz is interesting for a reason more durable than the "Slack killer" headline — Block is trying to make shared context independent from any one AI model or coding harness, so a team can keep its channels, project decisions, files, Git events, and agent identity in one open workspace, then change the engine underneath an agent from Claude Code to Codex, Goose, or another ACP-compatible harness. That's a meaningful architectural direction, because model access is becoming interchangeable while accumulated context is not.

In other words, you can swap out which model or coding tool is "driving" an agent, and the conversation history, decisions, and files it has access to just carry over. That's a real departure from how most teams currently work with AI — where switching from, say, Claude to Codex usually means starting a fresh context from scratch.

What can an agent actually do once it's in a channel?

Agents in Buzz aren't limited to answering questions. The difference is what agents can actually do once they're inside: open repos, send patches, review code, run workflows, edit canvases, orchestrate other agents, drop into voice huddles, create channels, and pull in whoever needs to see it — the same affordances as a human teammate, the same audit trail, just a different keypair.

That voice piece is worth calling out specifically, since it's easy to miss. Real-time voice runs over a WebSocket Opus relay built into buzz-relay, which authenticates participants and admits them to a room and forwards audio frames between peers — agents join the same audio relay as humans, bringing their own speech-to-text and text-to-speech. Instead of typing instructions back and forth, you can talk through a problem live with an agent in the room, the same way you'd loop in a colleague on a call.

Agents also get organized rather than dumped in as a single generic assistant. Agents aren't monolithic — a persona bundles a model and a system prompt, and a team is a named group of personas, so you can deploy one agent for code review, another for research, and another for cross-checking work. That solves a real problem anyone using multiple agents has run into: forgetting which agent was configured for which job.

How do you actually install and run it?

If you want to try Buzz yourself, start with the official GitHub repository, which has the clearest setup instructions. There are three main paths:

Option 1: Download a packaged build. Grab a packaged build from the latest release — macOS (.dmg), Linux (.AppImage / .deb), or Windows (.exe) — install it like any other app, and by default the app connects to ws://localhost:3000; to point it at a relay you're running or one someone shared with you, set the BUZZ_RELAY_URL environment variable before launching, or switch the relay from inside the app.

Option 2: Use Block's hosted version. There's a free hosted version at buzz.xyz currently in early beta. This is the fastest way to poke around without setting up any infrastructure yourself.

Option 3: Self-host from source. This is the route for teams that want full control. Clone github.com/block/buzz, then run 'just setup && just build && just dev' — this starts the Rust relay plus PostgreSQL, Redis, and MinIO locally, with requirements including Docker, plus the bundled Hermit toolchain or Rust 1.88+, Node 24+, and pnpm 10+. Packaged desktop apps can then connect via the BUZZ_RELAY_URL environment variable.

Once you're in, connecting a coding agent means wiring up the harness for whichever tool you already use. Buzz doesn't lock you to one AI provider — it supports Goose, OpenAI Codex, and Anthropic Claude Code as agent harnesses through the open Agent Client Protocol standard, wired up through the buzz-acp package included in the monorepo. If you don't already have a preferred harness, Goose is a reasonable starting point since it's the open-source agent framework Block first released in January 2025, so it's the path of least resistance on day one.

Can you actually build and deploy a full app with it?

Yes — and this is where Buzz gets practical rather than theoretical. A common demo pattern is having an agent scaffold and ship a real full-stack app straight from the chat, using Wasp, a full-stack framework for React, Node.js, and Prisma. Check out Wasp's official documentation to see how the framework compiles a high-level app spec into a working front end, back end, and deployment config.

Wasp pairs particularly well with agent-driven builds because it's a batteries-included full-stack framework built for the AI era, letting you develop JS/TS web apps using declarative code that abstracts away complex full-stack features like auth, background jobs, RPC, email sending, and end-to-end type safety. Once an agent generates the app, deployment is a single command away. Using the Wasp CLI, you can deploy a new app to Railway with one command — check Wasp's Railway deployment guide for the exact steps, including setting up your database and environment variables.

The workflow looks roughly like this inside Buzz:

1. Open a channel and bring in a coding agent (Claude Code, Codex, or Goose) via its persona
2. Describe the app you want — for example, a CRM to track customer data
3. Let the agent scaffold the app using Wasp's declarative spec
4. Review the generated code directly in the channel, where patches and comments live in the same event log
5. Deploy to Railway using Wasp's one-command deploy, with the whole build-review-ship loop staying visible to the whole team

What should you NOT do with it yet?

Buzz is exciting, but it's genuinely early software, and pretending otherwise would be a disservice. Block itself calls it "early stages," it's pre-1.0, and TechCrunch flatly says don't port your team over yet.

There are real, unresolved questions worth taking seriously before you put anything sensitive in it:

Security and data leakage. The launch drew pointed skepticism on Hacker News, where a Slack employee raised data-leakage concerns specific to multiple agents operating in shared channels — the core security question is real, since an agent in a channel can read everything in that channel. Block's counter is that agents get scoped identities and full audit trails instead of blanket bot tokens, though whether that holds up under real multi-tenant use is unproven, and Block does not claim otherwise.

Infrastructure limits. The early-stage workspace relies on one authoritative relay and lacks peer-to-peer exchange or relay replication. If that relay goes down, so does your workspace.

Missing pieces. At launch, Buzz offered desktop builds, while mobile clients, push notifications, and complete approval gates remained unfinished. Block's own documentation is candid about this — Block's engineering blog calls the beta "useful today" with "rough edges and giant chasms," so calibrate expectations accordingly.

If you're testing this with real work, keep sensitive data out of it for now. Before inviting an agent into a workspace, document what it can read, which external services receive prompts, where files are stored, and whether logs contain credentials or personal data — use separate test channels for experiments, and never paste API keys, private customer information, production secrets, or regulated data merely because the interface looks like an ordinary team chat.

Is this actually a big deal, or just hype?

Depends what you're measuring. As a Slack replacement today? Not yet, and Block would tell you the same thing. As an architecture bet? That's a different question. The idea that agent identity and team context should be portable — independent of whichever coding harness happens to be trending — is a real structural argument, not marketing copy. That's a meaningful architectural direction: model access is becoming interchangeable, but accumulated context is not — the valuable asset is the record of what the team decided, what the agent tried, what passed review, and what remains unresolved.

It's also not happening in isolation. Anthropic recently hired the leadership team behind Zulip, another open-source team chat tool, which suggests more than one company is betting that the harness and the coordination layer are going to be built by different teams entirely. Whether Buzz ends up being the winning coordination layer or just the loudest early attempt, the direction it points in — agents as portable, identity-bearing teammates rather than disposable bot accounts — is worth paying attention to regardless of which specific app wins.

The smartest move right now isn't adopting Buzz for production work. It's cloning the repo, spinning up a self-hosted instance on a spare afternoon, and watching what actually happens when you hand a coding agent a real task inside it. You'll learn more about where agent-native software is headed from thirty minutes of poking around than from any amount of reading about it.