Jack Dorsey's Buzz: Agents, Git, and Markdown

On July 21, 2026, Block — Jack Dorsey’s company, the one behind Square and Cash App — shipped Buzz, a team workspace where AI agents are members, not integrations.

It looks like Slack. It hosts your Git repos like GitHub. And every message, commit, review and agent action lands in the same signed event log. Dorsey’s own summary of it: model-agnostic, decentralized, self-sovereign, open source.

It is genuinely interesting. It is also pre-1.0, and TechCrunch’s advice — don’t move your team yet — is the right read. Here’s what it actually does, and the part it deliberately leaves to you.

What Buzz actually is

Strip the launch coverage and there are four design decisions worth knowing.

It runs on Nostr. Not a proprietary account system — an open protocol for signed messages and portable identities. Every action in Buzz is signed by a keypair. The relay itself is written in Rust, backed by Postgres, Redis and S3-compatible object storage, and licensed Apache 2.0.

Agents have their own identity. This is the piece most “AI in your workspace” products get wrong. In Buzz, an agent doesn’t borrow your credentials — it gets its own key, and you sign a narrowly scoped authorization for it. If the agent is compromised, you revoke the agent, not yourself. Block’s phrasing is the sharpest line in the whole launch: authorization does not erase authorship.

Channels are branches. A feature branch shows up as a channel. Patches, CI results and review comments sit next to the conversation that produced them, instead of three tabs away. Under the hood, Git lives on object storage as immutable content-addressed packfiles plus one mutable pointer, updated with compare-and-swap — which is how they intend to survive machine-speed commit volume.

It speaks Agent Client Protocol. Buzz is model-agnostic through ACP, so Claude Code, OpenAI’s Codex and Block’s own open-source goose all plug in. The buzz-acp bridge spawns agent subprocesses (1 to 32, default 1), connects to the relay over WebSocket, and queues @mention events per channel — one prompt in flight at a time, per channel.

The real bet: shared context beats private prompts

The thesis under all of that is simple, and it’s correct.

Today, every agent session is a private room. You paste context into Claude. Your teammate pastes different context into Codex. Neither agent knows what the other was told, and neither knows what the team already decided six weeks ago. Every session starts by reconstructing a world that already exists.

Buzz’s answer is to put the agents in the room where the context already lives. The report, the rejected fix, the patch, the review and the final call all stay in the channel — searchable later, with the reasoning attached.

That’s a real fix for one specific kind of amnesia: what happened inside the team.

The knowledge that isn’t in your workspace

Here’s the gap.

Most of what an agent needs to be useful was never said in your Slack, your Buzz, or your Git history. It’s the vendor’s API doc. The competitor’s pricing page. The RFC someone linked once. The long blog post that changed your architecture. The YouTube talk with the one number that mattered.

That knowledge lives on the open web, and it has three properties that make it hostile to workspaces:

• It rots. Pages get rewritten, paywalled, or 404’d. A link in a channel from March may point at nothing in August.
• It’s not yours. You can’t grep it, diff it, or feed it to a local model. You can only re-fetch it and hope.
• It doesn’t migrate. Workspaces die, get acquired, or get replaced. Anything trapped inside one leaves with it.

Buzz is honest about being an event log for work. It was never designed to be your library. Something has to be.

Markdown is the part that survives

Notice what Buzz’s own team reached for the moment they had something durable to say: an ARCHITECTURE.md in the repo. Not a wiki page. Not a pinned message.

That’s not an accident, and it’s not nostalgia. Markdown is the only content format that is simultaneously:

• Readable by every model without a parser, a plugin, or an export step
• Diffable in Git, so knowledge gets version control for free
• Local and plain, so no vendor is between you and your own notes
• Portable across every tool you might use next — Obsidian, Cursor, Claude Code, a static site, grep

Agentic tooling converged on this in 2026 from every direction at once: AGENTS.md, CLAUDE.md, llms.txt, Cloudflare serving Markdown to crawlers. The interface layer keeps changing. The substrate stopped changing.

Where Minibase fits

Buzz gives your agents the team’s context. Minibase gives them the web’s — as files you own.

You click the extension on anything worth keeping: a doc page, an X thread, a YouTube talk, a competitor’s changelog. It comes back as clean Markdown, written straight into your local Minibase Vault. Then Minibase Vault’s built-in MCP server exposes that vault to Claude, so the model checks what you’ve actually read before it answers from general knowledge.

Two different memory problems, two different answers:

	Buzz	Minibase Vault
Remembers	What the team did and decided	What the team read and learned
Format	Signed Nostr events	Plain .md files on disk
Lives	In a relay	In ~/Documents/Minibase Vault/
If it goes away	Export and pray	You already have the files

They’re complementary, not competing. The channel is where work happens; the vault is where reading accumulates — and once the vault has enough in it, the connections between notes start being worth more than the notes. If you’re evaluating Buzz, the useful question isn’t “does this replace Slack” — it’s “what am I about to put inside a pre-1.0 workspace that I’d want to still have in three years?”

Whatever the answer, keep that part in Markdown.

The practical version

1. Try Buzz on a side project, not your main repo — it’s early, by Block’s own description.
2. Keep decisions that matter in the repo as Markdown (ARCHITECTURE.md, AGENTS.md, ADRs), not only as messages.
3. Save the external sources your team keeps re-linking into a Markdown vault instead of re-fetching them.
4. Point your agents at both.

Agents joining the workspace as first-class members is the right direction, and Buzz is the most thought-through version of it so far. But an agent is only as good as what it can read — and the most valuable things it needs to read were never posted in your channels.

---

Minibase turns any webpage into clean Markdown in one click, straight into a local vault your AI can search. The extension is free with unlimited saves; Minibase Plus ($5.99/mo or $34.99/yr) adds AI templates, saved history and video transcription. minibase.md.