Jack Dorsey's newest company, Block, just shipped something people are already calling a Slack killer: Buzz, an open source, agent-native chat app built on an open protocol. If you are wondering how "buzz vs slack" actually shakes out, the short answer is that Buzz was designed from day one for teams where some of the teammates are AI agents, while Slack was designed for humans and only got agents bolted on later through integrations.
This breakdown is grounded in a walkthrough of Buzz by Vinny (co-founder of Wasp) on Greg Isenberg's The Startup Project podcast, where he demoed the app live. Here is what actually changed, and who should care right now.
Key Takeaways
- Buzz, Jack Dorsey's Block, treats agents as first-class teammates with their own profiles sitting in the channel list, not bolted-on integrations like in Slack.
- Every agent runs on a swappable harness (Claude Code, Codex, Goose, Open Code), so switching models keeps all chat history and context intact.
- Agents have Git tightly integrated: they build in a parallel worktree, push a feature branch, and can deploy live, all without ever touching files on your machine directly.
- Built on the open Nostr protocol, Buzz supports shared compute across a team and full data ownership since chats live on relays you control, not a closed platform.
- Vinny (Wasp co-founder) called it beta or alpha software right now, a fit for solopreneurs and small teams, not large engineering orgs shipping complex systems.
- For PMs, the real unlock is standing agents that hold context on a competitor's changelog or interview notes, part of the wider shift toward fewer tool hand-offs.
Learn this hands-on
Become a 10x PM by learning how to use Claude Code in your daily work as a Product Manager, through 3 highly efficient live sessions of 1h30. Join the Claude Code for PMs live cohort.
What Is Buzz?
Buzz is Block's take on team chat for the agentic era. It looks like Slack: channels, huddles, teammates. But under the hood, agents are members of your team, not add-ons. In Slack, an agent shows up because you installed an integration. In Buzz, agents are first-class citizens with their own profiles sitting next to your human teammates in the same channel list.
It is early software. In the podcast, Vinny described it as beta, maybe even alpha, and said the sweet spot right now is solopreneurs and small teams iterating on ideas, not large engineering orgs shipping complex systems.
Buzz vs Slack: The Core Difference
The headline difference in the buzz vs slack comparison is not the chat UI, it is what happens underneath each agent. Every agent in Buzz sits on top of a swappable harness: you can point it at Claude Code, Codex, Goose, or Open Code, and switch between them without losing anything.
That matters because AI moves fast enough that model fatigue is real. You get used to one model, and a week later there is a better one, but re-building context from scratch is a tax nobody wants to pay. In Buzz, you change the harness under an agent and every chat, every project, every piece of context you built up stays with that agent. Slack cannot do that, because in Slack the agent is not the thing that owns your context, the integration is.
On top of that, agent skills you have already set up globally (the kind you would use with Claude Code) carry straight over into Buzz, as long as they live in your global directory rather than being project-specific.
Audio Huddles and Building Software Inside the Chat
Buzz supports audio huddles with agents: you open a voice call, an agent joins with the full context of your chat history, and you talk it through out loud instead of typing back and forth. Vinny had not tested this extensively himself, but flagged it as one of the features he was most excited to dig into, since live back and forth is often faster for creative work than typed prompts.
The bigger unlock is that agents in Buzz have Git tightly integrated. Ask an agent to build something, and it creates a proper feature branch and works inside a parallel git worktree, so it is never touching files directly on your machine. Buzz also runs its own git hosting on your relay, the server that holds your chats and data (either self-hosted or hosted for you by Block), so code, conversations, and context all live in one place instead of being split across Slack, GitHub, and a dozen tabs.
In the demo, Vinny asked an agent in a chat to spin up a CRM using the Wasp framework and deploy it to Railway. The agent built it, pushed the code, deployed it live, and sent back screenshots and links, all inside the same conversation where the idea was discussed. He later built a second example: a tweet leaderboard that pipes daily stats into a Buzz channel through a public API, so the team can ask an agent things like "what is the common thread between my top tweets this week" without ever leaving the chat.
Shared Compute and the Open Protocol
Buzz is built on Nostr, an open, decentralized protocol, rather than a closed platform Block fully controls. That openness is also why integrations like the tweet API workflow above come together quickly, without needing to register an app or manage API tokens the way Slack requires.
It also enables a "shared compute" setting: a small team can run one local AI model on one machine and share it across everyone's Buzz clients, rather than each person paying for their own frontier-model subscription. Vinny framed this as a real alternative for a scrappy team that cannot yet justify a full unlimited-token plan per seat.
The same openness is behind an unreleased but expected feature: Nostr's tight coupling with Bitcoin Lightning payments, which would let people (or eventually agents) tip each other directly inside Buzz for work done, without a platform taking a cut. It is not built yet, but the protocol groundwork is already there.
The strategic point both hosts kept coming back to is data ownership. With Slack, your team's entire history lives on Slack's platform, and if you leave, you are effectively leaving that context behind. Because Buzz runs on an open protocol over relays you can host yourself, that lock-in risk goes away.
Buzz for Product Managers
If you spend your day moving between competitor teardowns, spec reviews, and discovery synthesis, the part of Buzz worth paying attention to is not the chat UI, it is the standing context. A PM could keep one agent loaded with a competitor's changelog and product pages, ask it to flag anything that shifts your roadmap, and pull it into a live huddle with the team the moment something changes, all without re-explaining the background every time. The same pattern works for keeping a running thread on user interview notes, or having an agent watch a public API for a metric you care about and post the digest straight into the channel your team already reads. It is the same direction most of the PM agent stack is heading: fewer hand-offs between tools, more standing agents doing the watching for you.
Buzz is not there yet for most teams. It is early, occasionally slow because everything routes through your relay, and not built for heavy engineering work. But the shape of it, agents as teammates with persistent context instead of bolted-on integrations, is worth understanding now, before it becomes the default.
Product manager and want to work like this? This is exactly what we teach in Claude Code for PMs, our live cohort for product teams: 3 live sessions of 90 minutes over 2 weeks. Every PM ships a real feature, builds their own agent, and gets personalized written feedback.
Should You Switch From Slack Today?
Not yet, for most teams, and that is fine. Buzz is early preview software: workflows and recurring tasks were not landing reliably at the time of the demo, and it can feel slower than working directly in Claude Code or Codex because every action round-trips through your relay. But if you are a solopreneur or a small team already living inside AI agents for most of your work, it is worth an afternoon to try. Worst case, you learn something about how you actually want to configure Slack. Best case, you get an early look at what team chat looks like once agents are teammates instead of tools.
