Jack Dorsey is at it again: Buzz wants to take over Slack, Cursor, and GitHub all at once.

Dorsey’s New Toy: A Client Aiming to Take Down Slack + GitHub + Cursor

On July 20, Jack Dorsey officially released Buzz through an independent development team under Block—a collaborative platform that merges team instant messaging, AI agent orchestration, and Git repository hosting. The goal is straightforward: to stop development teams from constantly jumping back and forth between Slack, GitHub, Linear, and Cursor.

This marks Dorsey’s second move into the collaboration/communication space this year. The first came in early July with Bitchat, a decentralized Bluetooth chat app that requires no account or server. Buzz takes the completely opposite approach—it’s not rebellious minimalism, but rather a textbook example of “platform integration.” You could even say Dorsey is aiming for something between GitHub Copilot Workspace and a Slack + Linear combo.

So What Exactly Is It

According to the official description and screenshots from early testers, the structure of Buzz can be summarized as follows:

• A desktop client, with a left-hand channel list almost identical to Slack, supporting DMs, groups, and topics;
• Each channel can host Agents, each with its own “identity.” Agents can be @mentioned and granted read/write permissions to repositories;
• Built-in Git hosting, with repos directly attached below channels so PRs, issues, and code reviews all happen in one interface;
• An Agent orchestration layer based on event-driven architecture, supporting function calls and long-running tasks. The official example: “Agent receives bug report → auto checkout branch → fix → open PR → notify human reviewer.”

In short, what Dorsey wants to build is a developer workstation “with chat as the shell, Git as the backbone, and Agents as the lifeblood.”

Why Dorsey, and Why Now

The timing is subtle. Over the past six months, the form factor of AI coding agents has been evolving rapidly:
Cursor and Windsurf follow the IDE-integration route,
Devin and Cognition push toward a “cloud-based asynchronous agent” model,
GitHub Copilot Workspace tries to embed the entire issue-to-PR workflow into GitHub,
and Anthropic’s Claude Code dives straight into the terminal.

No one has treated “team communication” as the primary battlefield for Agents.

That’s exactly where Buzz is placing its bet—the true core action in development collaboration is “discussion,” not “writing code.” From requirement to launch, the amount of information exchanged in chat far exceeds that in an IDE. If Agents naturally live within chat streams, they can capture PRD discussions, bug reproduction steps, and ad-hoc decisions that happen in Slack but remain invisible to GitHub.

This idea isn’t new—Slack is pushing Slack AI, and GitHub is embedding Copilot into Discussions. But the problem with existing players is this: Slack has no code; GitHub has no chat. Starting from a blank slate gives Buzz an actual chance.

Some Technical Details

Based on developer documentation and feedback from a few invited beta teams, Buzz’s backend architecture includes several key points:

1. WebSocket for the messaging layer, REST for agent calls—matching mainstream agent frameworks;
2. Containerized agent runtimes—each agent instance runs in an isolated sandbox with its own file system and network policy. This matters a lot for enterprise users; no one wants agents running around with root access;
3. An open model layer, not tied to any single model provider. Teams can specify GPT‑5, Claude, Gemini, or self‑hosted open‑source models in the agent configuration;
4. A self‑developed Git layer, not a fork of Gitea or Gogs. The Dorsey team claims this allows more granular operations on history and branches.

Point 4 is the most ambitious—and the most likely to backfire. Building a custom Git server means re‑implementing permissions, LFS, CI integrations, and the webhook ecosystem. That’s a colossal workload. It took GitLab over a decade to catch up with GitHub; Buzz trying to shortcut that path is a tall order.

Relationship with Bitchat

Interestingly, Buzz and Bitchat follow nearly opposite product philosophies:

• Bitchat: Decentralized, no account, Bluetooth mesh, privacy‑focused for geeks;
• Buzz: Centralized service, enterprise accounts, agent orchestration, developer‑oriented.

Dorsey hasn’t explained the connection between the two projects, but organizationally within Block, they’re parallel experimental product lines. In other words, Dorsey is placing two bets at once: one that “communication infrastructure should be freer,” and another that “developer collaboration should be more centralized.”

A Few Things to Worry About

As someone who’s been in this industry for a while, I have a few immediate concerns about Buzz:

First, agent permission boundaries. An agent that can read/write repos, send messages, and trigger CI pipelines—once hit by a prompt injection—can cause way more damage than a conventional CI mishap. Buzz claims to have sandboxing and permission systems, but its auditing capabilities remain undisclosed.

Second, migration cost. Moving from Slack + GitHub to Buzz requires migrating historical messages, issues, PRs, and webhooks. Currently, Buzz only provides Slack message import and Git repo mirroring; Issue and PR migration tools are not yet available.

Third, the business model. Block currently prices Buzz at $20 per user per month, including a quota of agent invocations. That’s slightly cheaper than Slack Business+ ($12.50) + GitHub Team ($4) combined, but how overage charges for agents will be handled isn’t clearly stated.

Fourth, model billing. Since Buzz supports integrating any model, teams must handle multi‑model API key management themselves. This is a typical pain point for agent platforms—product managers might use GPT‑5 for copywriting, backend engineers prefer Claude for coding, data analysts rely on Gemini for long‑text analysis… managing keys and invoices becomes a pure ops burden. Hooking into an aggregation gateway like OpenAI Hub—which unifies keys across models—would simplify things, and Buzz’s agent configuration indeed supports custom base_url.

Assessment: Sexy in Concept, Hard in Execution

Bundling chat, agents, and Git into one client makes sense—arguably, it’s inevitable. The developer toolchain has been fragmented for too long, and the rise of agents has opened a window to “re‑integrate” everything.

But Buzz is facing heavyweights on three fronts:

| Layer | Existing Giant | Buzz’s Challenge | |--------|----------------|------------------| | Team Chat | Slack, Lark | Strong network effects, high switching cost | | Code Hosting | GitHub, GitLab | Hard to replicate ecosystem & CI integration | | AI Coding | Cursor, Copilot | User habits already entrenched |

Winning on any one front alone is tough; fighting all three simultaneously is hell‑mode.
Dorsey’s bet is that in the agent era, these layers will reshuffle—and whoever delivers the smoothest all‑in‑one experience wins the entire developer desktop.

It’s an ambitious but far‑from‑certain wager. So far, Buzz only scores points for vision. The real answer will depend on its product iteration speed over the next 6–12 months, and whether a few seed teams genuinely move their workflows over.

From Twitter to Block to Bitchat and now Buzz, Dorsey’s style has always been “launch something and see what the market says.” Buzz will likely follow the same pattern—run for a while, then check whether developers are actually willing to chat and code in the same window.

If he guesses right, the collaboration‑tool track could get a lot livelier in the next two years.

References

• AI Agent Architecture Reference – Zhihu: Industry discussion on AI agent classification and autonomous agent concepts
• Multi‑Agent Collaboration System Example – GitHub: Reference for multi‑agent collaboration flow and engineering practice