Block's Open-Source Buzz Platform Puts AI Agents and Humans in the Same Team Chat Room

What Buzz Actually Is

Buzz isn’t another chat app with AI sprinkled on top. It’s the pipe — the event log, the search index, the shared workspace — that lets humans and agents operate as teammates, not tools. Jack Dorsey’s Block launched it on July 21, 2026, and it’s not a side project. It’s a direct challenge to Slack’s dominance and GitHub’s fragmentation.

The core idea is radical: one workspace, one identity, one event log. No more switching between Slack for chat, GitHub for code, Jira for tickets, and a dozen other tools that pretend to talk to each other. In Buzz, every message, every git commit, every workflow trigger, and every agent action is a cryptographically signed Nostr event in the same log. Humans and agents have the same surface area. The same permissions. The same audit trail. The only difference? A different keypair.

It’s not about making bots smarter. It’s about making the workspace smarter. The platform doesn’t think — it remembers. It connects. It surfaces.

I’ve seen teams waste hours stitching together workflows. Buzz cuts that Gordian knot. One room. One search. One place where the work lives — and where the memory of the work lives too.

The desktop app? Free. Available for macOS, Windows, Linux. The source? Open on GitHub. But don’t mistake open source for "easy." This is a deep infrastructure play. It’s not for the faint of heart. And Dorsey’s own warning is blunt: "It’s in its early stages." Don’t port your team over just yet. But if you’re building something new? This is the substrate you want to build on.

Agents as Real Teammates, Not Bots

Forget the word "bot." Buzz doesn’t have bots. It has agents — members of the workspace with their own secp256k1 keypairs, their own channel memberships, and their own audit trail.

In Slack, an AI agent is a script that responds to triggers. In Buzz, an agent is a teammate. You invite them to a channel the same way you invite a person. They can open repos. Send patches. Run workflows. Join voice huddles. Edit canvases. Orchestrate other agents. They don’t just reply — they act.

The difference is profound. In Slack, you ask an AI to "triage this bug." In Buzz, you give an agent read access to the bug channel, and it watches. When a new issue appears, it searches six months of history, finds the last time this error occurred, posts the root cause, and tags the engineer who shipped the last fix. All of it — the question, the search, the evidence, the tag — lives in the channel. Permanent. Searchable. Auditable.

And here’s the kicker: agents aren’t privileged. They’re scoped. You don’t give them admin rights. You give them access to specific channels, just like you would a junior engineer. Their identity is portable across communities, but their profile and permissions are local. Your agent in your company’s Buzz instance is not your agent in your partner’s instance. That’s intentional. That’s sovereignty.

This isn’t automation. It’s delegation. And it’s why Buzz’s vision document says: "The platform made it possible. The agent made it happen. Buzz is the pipe — not the brain."

The agents are your team’s memory. Your workflow. Your second brain. And they’re not hidden in a dark API. They’re right there in the room, with you, signing events with their own key. You can see who did what. When. Why.

The Tech Stack: Rust, Nostr, and a Relentless Focus on the Event Log

Buzz is built on a stack that screams "engineer’s dream" — and "business’s nightmare."

The backend? Rust. A Cargo workspace of focused crates: buzz-relay, buzz-db, buzz-auth, buzz-pubsub, buzz-search. It’s fast, safe, and designed for high-throughput event processing. The desktop client? Tauri + React — a lean, native-feeling app that doesn’t require Electron’s bloat.

The protocol? Nostr. NIP-01. Every message, reaction, workflow step, git event — it’s all a signed Nostr event. No blockchain. No crypto tokens. Just cryptographically signed events in a single, append-only log. The same structure whether the author is a human or an agent. The same keypair model. The same audit trail.

The data layer? Postgres 17 for the event store and full-text search. Redis for pub/sub and presence. S3 or MinIO for media, using the Blossom protocol. It’s not sexy. But it’s proven, scalable, and self-hostable.

The real genius? The event log is the single source of truth. Not the database schema. Not the API endpoints. Not the UI. The log. Everything — the chat thread, the git commit, the workflow run, the approval — is an event in that log. Search it. Replay it. Audit it. Build on it.

This is why Buzz can do what other tools can’t. When you search for an error message in Buzz, you’re not just searching chat. You’re searching the entire history of the project: the PRs, the CI logs, the workflow runs, the agent summaries, the voice huddle transcripts. All of it. Indexed. Together.

It’s not a feature. It’s the architecture.

Branch-as-Room: Git Isn’t Separate Anymore

Here’s where Buzz gets weirdly brilliant.

In every other tool, you create a feature branch in git. Then you create a ticket in Jira. Then you create a channel in Slack to discuss it. Then you create a PR in GitHub. Then you wait for CI to run. Then you wait for reviews. Then you merge. Then you delete the branch.

The work is scattered. The context is lost.

Buzz kills that. When you create a feature branch, Buzz creates a channel. Automatically. The channel is named after the branch. It’s private. Only the team working on it can see it.

Now, everything that happens around that branch lives there:

• Git commits? They become Nostr events in the channel.
• CI results? Posted as reactions.
• Code reviews? Comments on the PR appear as threaded replies.
• The merge decision? It lands as a final event.

When the branch is merged, the channel doesn’t vanish. It archives. It becomes a permanent, searchable record of why that code exists.

No more "what was the context for this change?" No more digging through Slack threads and GitHub PRs. You open the channel. You see the whole story. From first commit to merge.

This isn’t integration. It’s unification. Git isn’t a separate tool. It’s a feature of the workspace. And the workspace remembers.

YAML Workflows: Automation That Actually Works

Slack has workflows. But they’re clunky. They require a UI. They’re brittle. They’re hidden.

Buzz has YAML-as-code workflows. And they’re beautiful.

You write a simple YAML file. It defines triggers: a message with a specific keyword, a reaction to a post, a scheduled time, or a webhook from an external system. Each trigger fires a step. The step can be: send a message, run a script, call an agent, wait for approval.

And here’s the kicker: every step is signed. Every step is traced. Every step is searchable.

Want to auto-generate release notes? Write a workflow that:

1. Watches for a git tag.
2. Pulls all merged PRs from the project’s channels.
3. Asks an agent to draft release notes.
4. Posts them to the channel.
5. Waits for a 👍 reaction from a human.
6. If approved, pushes the release.

Every step is logged. You can audit who approved it. When. Why. You can replay it. You can modify it. You can share it.

This isn’t automation for engineers. This is automation for teams. And it’s not a premium feature. It’s free. Built-in. Open source.

The infrastructure for approval gates already exists — the UI, the API, the database schema. The executor just needs to persist the approval token and resume execution. It’s not done. But it’s coming. And when it is, Buzz will be the first platform where workflows don’t just run — they have a human-in-the-loop, auditable history.

Self-Hosting and Data Sovereignty: The Real Differentiator

Buzz is open source. But it’s not just open. It’s sovereign.

The URL is the community. myproject.com is your workspace. That’s it. No shared data. No cross-community leaks. Even if ten companies share the same relay infrastructure, their data is formally isolated. Proven with TLA+ and Tamarin model checking. Not "we promise." Not "we try." Proven.

Your keypair is yours. Your profile is per-community. You can join ten different Buzz communities with the same keypair, but your DMs, your channel memberships, your audit trail — they’re all local to each community. No leakage. No cross-pollination.

This isn’t a feature. It’s the foundation. And it’s why enterprises are watching.

You can self-host Buzz on your own hardware. You can run it in your own data center. You can control every byte. No vendor lock-in. No cloud dependency. No "we’ll handle security for you" — you handle it. And that’s the point.

Buzz doesn’t just give you control. It gives you control that’s provable. That’s why it’s not just a Slack killer. It’s a new paradigm for enterprise software: owned, operated, and audited by the user. Not the vendor.

The Competition and Why Buzz Wins

Centaur, from Paradigm’s Georgios Konstantopoulos, is Buzz’s closest cousin. Launched in May 2026, it’s a "virtual employee" that runs inside Slack or via API. It’s clever. But it’s a patch. It’s an AI agent glued onto an old platform.

Buzz isn’t a patch. It’s the whole system.

Centaur lives in Slack. Buzz is the replacement.

Centaur needs your team to use Slack. Buzz doesn’t care what you used before. It gives you a new home.

Centaur’s intelligence is in the model. Buzz’s intelligence is in the workspace. The memory. The context. The connections.

And then there’s Slack itself. Still the default. Still bloated. Still charging for features Buzz gives away for free: workflow automation, git hosting, search across code and chat.

Buzz wins because it doesn’t try to be everything. It tries to be one thing: the single source of truth for a team’s work. Everything else — chat, code, automation, agents — flows from that.

It’s not the most polished tool today. But it’s the most honest. And in a world of AI hype, honesty is the rarest currency.

Final Thoughts: The Beginning, Not the End

Buzz isn’t finished. It’s barely started.

Mobile apps are coming. Culture features — custom emoji, coffee roulette, kudos — are planned. Push notifications are still being wired. The approval gate executor is broken.

But the core? The event log. The unified identity. The agent-as-teammate model. The branch-as-room paradigm. The YAML workflows. The self-hosted sovereignty.

That’s all there.

And it’s enough.

If you’re building something new — a startup, a research team, a dev team tired of juggling tools — Buzz is the platform you want to build on. It’s not for everyone. It’s not for the lazy. It’s for the builders who want to own their workspace. Who want their team’s memory to be theirs. Who want their agents to be real teammates.

It’s not the future of work.

It’s the present. And it’s open source.

Grab the app. Run the relay. Join the community.

And if you’re lucky, you’ll be one of the first to build on a workspace that remembers.