Shared Compute: The Quiet Idea Inside Buzz That Small Teams Should Actually Care About

By fast2future · July 27, 2026 · Build-in-public series

On July 21, 2026, Block released Buzz, a free and open-source workspace where human teammates and AI agents sit in the same rooms. Most of the coverage led with the obvious frame: Jack Dorsey is coming for Slack, and for GitHub while he’s at it. That framing is fair — TechCrunch reported it that way, and the app really does fold chat, code repositories, and workflows into a single surface.

But the head-to-head framing buries the part worth your attention. Tucked into the release is a feature that quietly changes what a small group can plausibly own — and it deserves a longer look than a competitor comparison gives it.

First, what actually shipped

Worth separating from the hype, because the specifics are checkable:

Buzz is built on Nostr, a decentralized relay protocol. In the default deployment a single relay hosts one community, and every message, reaction, workflow step, code review, and git event is recorded as a signed event in a hash-chain log. It is licensed Apache 2.0, published openly, and shipping as version 0.4.21 — desktop builds for macOS, Windows, and Linux, with mobile still pending. Teams can self-host it or use Block’s managed version.

The agent handling is the genuinely thoughtful part. Every participant, human or machine, holds their own cryptographic keypair. As Block’s engineering team puts it, Buzz “gives each agent its own key. The agent’s owner signs a narrowly scoped authorization. The agent then signs its own work with its own identity.” Authorization and authorship stay separate: you can always see what an agent did, who permitted it, and under what limits. Identity and history travel with the agent across any Nostr-compatible system rather than being trapped in one vendor’s database.

It is also model-agnostic by design — agents built on Anthropic’s Claude Code, OpenAI’s Codex, or Block’s own goose framework all work, along with anything else speaking the Agent Client Protocol. Change the model underneath and the project keeps its identity, permissions, and history.

Bradley Axen, Block’s head of AI capabilities, framed the bet plainly: “Every company is going to need a place where humans and agents work together. The question is whether that place is proprietary or open.”

The part almost nobody led with

Here is the feature that makes this more than a nicer chat app.

Buzz lets a community pool its hardware. From Block’s engineering write-up: Buzz “can also run an agent’s model requests on another community member’s machine. That lets a team share GPUs and inference capacity without sending prompts through the Buzz server.” Buzz introduces authorized peers to each other, and then encrypted model traffic travels directly between those machines — the central server sees routing metadata, not the contents.

Dorsey put the user-facing version of it more bluntly on X: it takes one click to make a local model available to your agents and to share that compute with other people, and from there your agents will automatically choose the largest or best shared model available to them.

Sit with what that removes. Capable open models exist now and are close enough to frontier quality to do real work. The catch has always been that the strong ones want expensive hardware, and standing one up is genuinely fiddly if you aren’t technical. That combination is why most small teams never seriously considered running their own — the math only worked for one person if that person happened to have both a workstation and a free weekend.

Pooling changes the math. One member with capable hardware can carry inference for the whole group. Everyone else clicks in. The cost of a real machine gets divided across the people who benefit from it, which is exactly the shape that made every other kind of shared infrastructure work.

Why this reframes the question everyone’s been asking

For three years the default question has been whose model is smartest? — a question you answer by picking a lab and paying them monthly. It’s a good question. It’s also one you have almost no leverage over, because the answer changes every few months and is decided entirely by people you’ll never meet.

Shared compute quietly surfaces a second question that you do have leverage over: what is this model sitting next to?

Because here’s the thing about a group that runs its own instance inside a workspace like Buzz. Every conversation, every decision, every patch and review and approval lands in a signed, searchable log that the group owns. The agents live in those rooms as members with their own identities and scoped permissions. They aren’t reaching into your context through a connector you rent — they’re already in the room where the context is made.

That’s a different kind of advantage than model quality, and a more durable one. Model capability is a rising tide that lifts everyone roughly equally; nobody gets to keep it. Proximity to a specific body of hard-won private context is not a rising tide. It’s yours, it compounds quietly with every week the group works, and no competitor picks it up by switching to the same provider you use.

Be precise about what this is not

This is where an honest read matters, because the enthusiastic version of this story overstates it.

You’ll see the shared-compute idea described as a community running a model trained on their own private data. That framing is doing something the shipped software doesn’t quite do yet, and the gap is worth naming. What Block documents is shared inference — pooled capacity to run a model — not shared fine-tuning. The weights are whatever open model somebody loaded. Nobody’s training run happens because you clicked the button.

The honest version is still good, just narrower: the model is generic; the context around it is yours. In practice that context layer — retrieval over a private corpus, an agent’s accumulated memory, the full signed history of how a group actually decided things — is where most of the usable advantage lives today anyway. Fine-tuning is the flashier idea and usually the less practical one at small scale. So the ownership argument holds. It just holds for a different reason than the shorthand suggests, and you should know which one you’re relying on.

A few other things to keep your eyes open about. Version 0.4.21 is early, and Block says so; this is not a thing to migrate a company onto next week. Someone still has to run and maintain the machine, and that person is now load-bearing for everyone else. Self-hosting anything is real ongoing work that quietly moves cost from a subscription line to your own hours. And Nostr is unfamiliar territory for most teams, which is a learning curve on top of a learning curve.

This is also not the only attempt at the idea — Paradigm’s Georgios Konstantopoulos released Centaur, a self-hosted agent approach aimed at Slack environments, in a similar spirit. When several credible people reach for the same idea at once, that’s usually a signal the idea is ripe rather than a signal that any one implementation has it right.

What it means if you’re small

The practical takeaway isn’t “adopt Buzz.” It’s that a door you probably assumed was closed turns out to be open, and it’s worth knowing that before you make your next few decisions.

If you’re a solopreneur, a four-person team, a church, a co-op, a group of builders who trust each other — the option to run capable AI together, on hardware you collectively own is now on the menu at a cost structure that isn’t absurd. That has been theoretically true for a while. What changed is that the setup burden dropped toward one click and the hardware burden got divisible.

Three things worth doing with that:

1. Notice what you’re renting, and what it would take to own it. Not as an ideological stance — renting is often correct, and frontier access is genuinely worth paying for. But a lot of teams have never once priced the alternative, so “rent” was never really a decision.

2. Start treating your group’s context as an asset. Whatever tool you use, the searchable record of how your people actually think and decide is the part that becomes valuable as models commoditize. Most groups let that evaporate into chat scroll. It doesn’t have to.

3. Watch this specific space rather than betting on it. Early, open, and interesting is a fine thing to learn from and a poor thing to depend on. Track it. Try it on something low-stakes. Let it mature.

The hopeful part

There’s a version of the next few years where capability keeps concentrating in a handful of enormous labs, and everyone else’s relationship to AI is a monthly bill and a hope that the terms don’t change.

Then there’s this version, where a small group with modest hardware and a shared purpose can hold real capability in common — not by out-spending anyone, but by owning the thing that was always actually theirs. That possibility got noticeably more real on July 21.

It’s a good week when the ceiling turns out to be a door. Go look at what you assumed you had to rent.