Short answer: Buzz is a free, open source team workspace built by Block (Jack Dorsey's company) and released on July 21, 2026. It looks like Slack: channels, threads, DMs, voice. With one fundamental difference: AI agents aren't integrations or bots. They're team members with their own cryptographic identity, their own permissions, and their own audit trail. It also ships code repositories, which puts it in competition with GitHub too.
If you work with Claude Code, Codex, or goose and you're tired of your project context living scattered across seven browser tabs, this launch matters to you. Here's what it actually is, what works today, what doesn't, and how to try it.
Who's behind Buzz
Buzz was built by Block, Inc., the company run by Jack Dorsey (co-founder of Twitter and Square/Block). Dorsey describes it as "model-agnostic, decentralized, self-sovereign, and open source."
The origin story is refreshingly honest: they built it to reduce their own dependency on Slack and GitHub, then decided to publish it so anyone could do the same. Bradley Axen, Head of AI Capabilities at Block, sums up the thesis: every company is going to need a place where humans and agents work together, and that place should be open.
The code lives at github.com/block/buzz under the Apache 2.0 license, written mostly in Rust, and it cleared 16,000 stars within days.
How it actually differs from Slack
The easy take is "Slack with AI bolted on." It goes deeper than that.
| Slack | Buzz | |
|---|---|---|
| AI agents | Integrations and bots with app tokens | Members with their own keypair, profile, and permissions |
| Code | You link out to GitHub | Repositories and git hosting inside the platform |
| Your data | On Slack's infrastructure | On a relay you can self-host |
| AI model | Whatever the vendor picks | Any: Claude, Codex, goose, or a local model |
| License | Proprietary | Apache 2.0, open source |
| Automation | Proprietary Workflow Builder | YAML workflows on open protocols |
The last row is the one that isn't cosmetic. In Slack, wiring up your own app means registering an application on their platform, managing tokens, and learning their structure. In Buzz, because it's built on open protocols, connecting your own tooling is a matter of minutes.
How Buzz works under the hood
This is what makes the pitch hold together technically. Buzz isn't a chat app with a message database. It's a Nostr relay with a workspace interface on top.
That means every message, every reaction, every code patch, every automation step, and every approval is a cryptographically signed event in one shared log. It doesn't matter whether the signer is a person or a process: same shape, same identity model, same audit trail.
Three practical consequences fall out of that design. First: an agent is a member, not an integration. It has its own keypair, its own channels, its own history. You add it to a channel the way you'd add a person, and you can review exactly what it did. Second: the relay is yours. The relay URL is the community. If you ever want to move, your data moves with you, something that is in practice extremely hard to do with Slack. Third: everything is searchable at once. The conversation, the code change, the CI result, and the approval are all the same kind of event and land in the same index.
For anyone who'll end up deploying it: a Rust relay, PostgreSQL for events and search, Redis for presence and real-time, S3 or MinIO for files, and a desktop app built with Tauri and React.
The killer feature: swap models without losing context
If you take one thing away from this article, make it this one.
Buzz separates the agent (its identity, its persona, its history in the channel) from the harness (the program that runs the model). The bridge between them is ACP (Agent Client Protocol). Supported today: goose (Block's own open source framework), Codex from OpenAI via the codex-acp adapter, Claude Code via claude-agent-acp, and buzz-agent (Block's own minimal agent).
Why does this matter so much? Because you can swap an agent's engine from the UI and the accumulated context stays put. Everything you discussed with that agent, the projects in flight, the decisions already made: still there, because it never lived inside the harness. It lives in the event log.
Anyone who's suffered model fatigue, switching tools every couple of months and starting from scratch re-explaining the project, gets the value immediately. And your globally installed skills keep working regardless of which harness you pick.
Practical tip: match each agent to the model its job deserves. A powerful model for reasoning about architecture, a cheaper one for routine work. Not every task is worth burning premium tokens on.
What you can actually do with it: two real examples
1. An agent that builds and ships a full app
On the Startup Ideas Pod episode that broke the tool down, Vinny (from the Wasp team) asked an agent to "spin up a simple CRM using the Wasp full-stack framework and deploy it to Railway."
The agent created the repository, wrote the code, deployed it to production, and posted the live link and screenshots back into the channel, before he'd even looked at what it was doing.
It works because agents operate in parallel git worktrees, not on your local checkout. You can ask for three different versions of a landing page at once without them stepping on each other.
2. The context loop (the part almost nobody caught)
This is the most valuable pattern in the whole story, and the least obvious. It isn't about an agent building an app. It's about the app it built feeding data back to the agent.
You ask for an app, say a dashboard tracking your content metrics. You ask that app to expose an API. You create a scheduled workflow that hits that API daily and posts the numbers into a channel. Now you reply in that thread: "what do my best-performing posts have in common this week?" And the agent already has the data in front of it. No CSV exports, no copy-pasting into ChatGPT.
That's the closed loop: context → agent → software → data → context. And it's portable: the same pattern works with n8n, with a cron job, or with Buzz. This is the boring work every business has, and it's usually where the real competitive advantage hides.
Shared compute: one local model for the whole team
Another underreported piece. In Buzz's settings you can turn on "share this machine," pick a local model, and let other members of your community use it from their own laptops.
The obvious scenario: three students with no budget for premium subscriptions pool their money, buy one decent machine, and share a local model across the group. Admission is gated by current community membership and cryptographic signatures, so it isn't an open port to the world.
It's early functionality, today it sits behind a compile-time feature flag, but the direction is clear: choosing your model shouldn't depend on who's selling you the subscription.
How to get started with Buzz: three paths
Path 1: hosted (5 minutes, no infrastructure)
Go to buzz.xyz, create your account and community with Block-provided hosting. Free in early beta. No pricing tiers or usage limits have been published yet, so treat "free" as a launch-phase fact, not a permanent guarantee.
Path 2: desktop app against an existing relay
Grab the installer from the repository releases: .dmg for macOS, .AppImage or .deb for Linux, .exe for Windows. It defaults to ws://localhost:3000; you can switch relays from inside the app or with the BUZZ_RELAY_URL environment variable.
Path 3: self-hosted (full control)
You'll need Docker and Hermit (or Rust 1.88+, Node 24+, pnpm 10+, and just):
git clone https://github.com/block/buzz.git && cd buzz. ./bin/activate-hermit && just setup && just buildAnd day to day:
just devFor production on a VPS there's a dedicated bundle in deploy/compose/ (PostgreSQL, Redis, MinIO, and optional Caddy with automatic certificates). Don't use the docker-compose.yml at the repo root: that one is local development only.
Before you wire this into your workflow: three security warnings
This rarely shows up in the coverage, and it's exactly what separates an experiment from an incident.
The agent gets a real shell. Buzz's tool server hands the agent a terminal and a file editor, and it runs at the operator's trust level, like bash itself. It is not a sandbox. If you give it access to the machine holding your production keys, that's precisely what you've handed over.
Check who can trigger your agents. By default an agent only responds to its registered owner (owner-only). There's a mode that opens it to anyone. Do not turn that on in a public channel. It's prompt injection served on a plate.
Your private key is your identity. Nostr has no "forgot my password." Lose the key, lose the identity.
So, should you leave Slack?
Not entirely, and it's worth being straight about that.
What already works: the relay, channels, threads, DMs, canvases, media, search, audit log, desktop app, an agent-first CLI, YAML workflows, git events, and repository hosting.
What doesn't yet: mobile clients (iOS and Android are in development), push notifications, and approval gates in workflows. People who've used it seriously flag two more things: recurring tasks aren't reliable yet, and there's noticeable latency compared to working directly in Claude Code or Codex.
The honest verdict: with no mobile and no push notifications, Buzz doesn't replace your Slack today. But it can absolutely be your second workspace, the place where agent work lives. It fits small teams and fast-iterating projects especially well; less so complex engineering or compliance-bound environments.
And even if you end up back in Slack, you'll have learned to configure it better. There's no losing move here.
What this tells us about the future of work
Whether Buzz itself wins or not, the underlying thesis is the part worth keeping: shared context is the foundation, and agents build outward from there.
What makes this tool interesting isn't "Slack with AI." It's that it put identity, context, code, and automation inside a single signed log, and handed infrastructure control back to the people using it. That design will outlive the product even if the product doesn't make it.
The skill that becomes valuable here isn't mastering Buzz. It's understanding what sits underneath: how an event protocol works, how to stand up and secure a service, how to design an API, and what an agent is really doing when it executes code on your machine. That doesn't expire with the next tool that trends.
If you want to go from reading about agents to building with them, 4Geeks Academy trains developers who work with this stack from day one: real projects, live mentorship, and support all the way to getting hired.
Published July 29, 2026. Sources: the official Buzz repository, Block's announcement, TechCrunch, and the Startup Ideas Pod episode with Greg Isenberg and Vinny (@hot_town).