~/posts/buzz-shared-compute
Buzz Shared Compute

Buzz Shared Compute

Understanding what shared compute is and how it can be used.

$ cat content.md

“…a distributed civilization. A civilization that perpetually regenerates. One with no central authority. Your only option is what form that civilization takes. And that depends on the actions of people like you.”

— Daniel Suarez, Daemon.

From central control to shared sovereignty

Computing has always involved a negotiation over where the work happens and who controls it. Mainframes, personal computers, cloud services, thin clients, and today’s local AI models reflect changing answers to that question. These approaches coexist because the tradeoffs keep changing: shared infrastructure offers scale and convenience, while running software on your own machine can offer sovereignty, privacy, and control.

New capabilities often arrive through centralized services because they require expensive hardware or specialized expertise. As the technology becomes cheaper and easier to run, more people can operate it themselves. While that isn’t an inevitable cycle, it creates a recurring opportunity: to take capabilities we once had to access through someone else and make them something we can own and operate together.

Communities are a natural place to explore that opportunity. A community creates more than the work it publishes. It creates relationships, knowledge, and a shared history of decisions. Those become part of its ability to do things together.

This is the thinking behind Buzz: give people and agents a place to work together, with identities they control and a history that belongs to their community. Conversations, repositories, and the decisions around them can live on a relay the community operates itself or chooses someone to host.

As agents take on more of that work, the same question extends to the infrastructure powering them. How much of the system can a community operate for itself?

This is where shared compute comes in.

Useful work on machines we already own

We believe shared compute is still criminally underutilized. Partly because so much attention goes to frontier models, partly because for a long time, the models most people could run on their own hardware also left a lot to be desired.

Luckily, that is changing. Local models are becoming capable enough to handle more useful, well-defined tasks. Our machines are becoming more powerful too. A laptop, gaming PC, or workstation can contribute capacity that would otherwise sit unused.

The question now becomes: what work is worth doing continuously when you have access to that capacity?

From local tasks to frontier experiences.

While the capabilities will change over time, we've been thinking a lot about the discrepancy between local models and frontier models.

New conversations need organizing. Documents need labeling. Decisions need extracting. Incoming information needs connecting to what the community already knows. Security scans needs to be performed. This work accumulates every day. Much of it can be handled by a suitable local model without requiring frontier-level reasoning.

At community scale, paying commercial API prices for every pass over every piece of information can become expensive. Shared compute gives us another way to supply some of that capacity, using hardware people choose to contribute. Electricity, maintenance, and hardware still cost something, but with shared compute that cost can be substantially reduced and the quality of our networks greatly improved.

Over time, as yesterdays frontier models become todays local models, what is possible will change in very meaningful ways. We want to make sure that Buzz can deliver those experiences and grow with the users, their models and their ambitions.

Let's explore some ways shared compute can be used.

Onboarding people and agents

Once connected to a shared model, an agent could help configure itself or create another agent using the setup tools and permissions available to it. For an open source community, that could mean welcoming a contributor with an agent powered by the community’s own machines. The agent could help them find their way through the project and prepare an agent of their own, without requiring a commercial model account to get started.

A new member’s introduction could start that work. A welcome agent could connect their interests to an open issue, find someone who has offered to help, and prepare a contributor-helper draft for them to review.

Loading image...
Juniper responds to a new contributor’s introduction in Buzz and prepares a helper-agent draft for review.

Sentiment and community health

Anyone who’s been running big online communities knows how stressful that can be. Sometimes people get into arguments they can’t get out of, and that can snowball into an actual flame war. An agent watching new messages could notice recurring frustration and collect the relevant conversation.

Loading image...
Lena and Ravi argue about changing release requirements while the background watcher Harbor notices the exchange.

A suitable local model could do that first pass continuously, passing the source messages to a more capable agent when something needs attention. That agent could read the surrounding discussion, check earlier decisions, and work out what is actually causing the disagreement.

Loading image...
Harbor asks Sage to review an escalating discussion; Sage checks the contributor checklist and an earlier maintainer agreement.

In this example, the problem turns out to be a release requirement that was added without updating the contributor checklist. Sage then informs the community admin, with sources and a specific suggestion for unblocking the conversation.

New community activity starts the work, and a person receives the context when it needs their judgment.

Loading image...
Sage sends Thomas a proactive notification about the release disagreement, with supporting sources and a suggested intervention.

Labeling and initial review

Consider labeling: categorizing large batches of transaction records, tagging new assets, organizing documents, and connecting related requests. An agent could work through incoming material as it arrives, linking a new request to an earlier decision and leaving uncertain labels for a person to review.

Loading image...
A knowledge-garden view shows documents labeled by Index, connections to earlier decisions, and items left for human review.

The same pattern could apply to initial review. A manifest watcher could notice that a plugin update requests new permissions or introduces an unfamiliar dependency, then bring the changes to someone for a deeper security review before installation.

Loading image...
Scout proactively flags new channel-history access in a Calendar Bridge update, with a manifest diff beside the message.

Each pass can improve the community’s shared knowledge. A stronger agent picking up a task could find relevant labels, linked discussions, and earlier decisions already prepared, with sources it can check.

Keeping sensitive work within the community

For some communities, where that processing happens matters as much as what it costs.

A group could use models running on trusted member machines to analyze internal discussions or sensitive documents within infrastructure it controls. With the workflow configured to use those models and avoid external services, that analysis can happen without sending the data to a commercial inference provider.

The boundary here is the trusted community infrastructure. Requests travel from the consuming machine to the machines serving the model; they don’t stay inside the relay process. The serving machines receive the information they process, so their operators are part of the trust decision.

That gives a community concrete choices about which machines participate and which information it sends to them.

Loading image...
Cedar posts a scheduled private policy briefing; a panel identifies the trusted model host, data scope, and disabled external services.

Markets, simulations, and games

There are more exploratory possibilities too. Agents could help interpret information for prediction markets, find capacity for inference jobs, reason through simulations, or power characters in a game. These would need their own applications and rules, but they share a need for recurring access to inference.

Evidence for a forecast

An agent could keep watching the sources behind a forecast and bring people meaningful changes: a completed milestone, a new blocker, or evidence that challenges an earlier assumption. The people maintaining the forecast would still decide what to do with that information.

Loading image...
Signal proactively notifies a person about new evidence affecting a release forecast and keeps the supporting evidence log alongside it.

A marketplace for inference

The marketplace could be for the compute itself. An agent with a batch of discussions to label could post an inference job with the model it needs, the amount of work, a deadline, and a budget. Agents representing participating machines could bid on that job.

Those machines might be distributed around the world. Their electricity rates could differ by location, provider, and time of day. Their hardware and available capacity would differ too. Each machine’s agent could turn its estimated power draw and running time into an energy cost, then include hardware time and a margin in its total quote.

Loading image...
Index posts an inference job and machine agents in Oslo, Berlin, and Austin bid with different electricity rates, hardware costs, margins, and completion times.

In the example, the Oslo machine offers the lowest quote that meets the job’s model, memory, and deadline requirements. The Berlin machine offers a faster completion at a higher price.

Once a bid is accepted, the requesting agent keeps responsibility for the task while the selected machine supplies inference. A market like this would need rules for validating results, accounting for work, and settling payment.

Loading image...
Fjord’s bid is awarded and the inference batch begins processing, with progress and the compute activity widget visible.

Simulations that report back

An agent could keep track of simulation runs, report a meaningful result when a run finishes, and help choose the next scenario. Shared inference capacity could support that ongoing analysis, keeping the assumptions and source results attached to its findings.

Loading image...
Atlas reports a completed energy simulation with a comparison of modeled peak demand, visible assumptions, and the next scenario queued.

Worlds that keep moving

In a game, background character agents could propose actions while players are away: arranging a delivery, finding help, or responding to a change in the world. The game host would validate those actions against its rules and own the persistent state.

Recurring inference could make that world feel inhabited between player visits.

Loading image...
A game prototype shows developments made by background character agents while players were away, with the game host validating world events.

How shared compute works in Buzz

As you can see the kind of things that can potentially be built with shared compute is quite literally infinite, and it's only going to get better as models become bigger, machines become more powerful and our ability to orchestrate becomes more sophisticated.

So what’s actually making all this possible?

To understand this, let’s first have a look at an example of how a request from an agent using shared compute looks like. In this following video you have a desktop app on the left serving as the token consumer and another on the right as the token provider.

The Shared Compute plugin connects model sharing to the community that people and agents already belong to. Buzz uses Mesh LLM to connect participating machines and route inference requests between them.

A member chooses to serve a model from their machine. Buzz uses community membership and verified compute announcements to discover participating peers. Another member can then configure an agent to use an available shared model.

The agent runtime and the model can live on different machines. The agent keeps working through its own tools while another machine answers its inference requests.

That is what makes this useful beyond the person with the most capable hardware. One member contributes a model; other members can use it without each downloading it or fitting it into their own machine's memory.

This is especially useful when you start looking at mobile phone or external hardware use such as Arduino and ESP-32 where access to compute is often going to be much more limited.

With shared compute this can still be served by the local community as in the example of one of the shared agents running a phone.

The community’s relay coordinates membership and discovery. Inference runs on participating machines over encrypted connections. As with the private briefing example, the people operating those machines are part of the trust decision.

A community can start with one person sharing one model and grow from there. Laptops sleep and machines get busy, which makes background work that can wait a useful place to begin.

Create your own agents and helpers

Loading image...
Buzz Shared Compute settings with model sharing enabled and Tools for creating a thread summarizer, translator, media converter, or custom agent.

The Shared Compute plugin also includes a Tools section where you can create helpers powered by the community’s shared models. Start with a thread summarizer, translator, or media converter, or create a custom agent around the work you need done.

Once created, the helper appears in Agents. You can edit its name and instructions, add it to a conversation, and mention it when you need it. A summarizer could help you catch up on a long release discussion. A translator could help you follow a conversation in another language. A custom agent gives you a starting point for something specific to your community.

The summarizer and translator reply in Chat mode, without tools. The media converter uses Agent mode and needs ffmpeg installed on the computer running it. Agent mode can work with files and use Buzz tools on that computer, even when another machine serves the model. Relevant tool output can also be sent to that machine, so the same trust decisions apply.

You can start with one small, useful helper and adjust it as you learn what works. Shared compute supplies the inference; the instructions and tools give that capacity a job to do.

Earn to burn: sustaining shared capacity

As more people depend on that capacity, communities will need ways to sustain it. Electricity, hardware, and maintenance still cost something, even when members already own the machines.

One possibility is “earn to burn”: contribute compute when your machine has capacity, earn credits for useful work, and spend them when your agents need someone else’s machine. A contribution today could support your agents tomorrow.

Over time, members could also offer that capacity for payment. Someone with a capable workstation could rent out time on it while it would otherwise sit unused. Their agent could bid on inference jobs based on the machine’s capabilities, availability, and operating costs, as in the marketplace example earlier.

That would give people a reason to keep useful capacity available and potentially invest in more. Making it dependable would require ways to verify work, account for contributions, and settle payments but these are things we are already exploring.

The same arrangement could extend across communities. One might have spare capacity when another needs it, or access to a model that another cannot run. Each community would decide what it wants to contribute, whose machines it trusts, and which requests may leave its own infrastructure.

Ultimately this might resolve in running completely sovereign payment rails. If millions of nodes were available around the world, just imagine what could be done with all that compute.

These are just some of the possibilities we want to build toward and explore with shared compute.

Shared sovereignty

Now to sum up this essay. If you got anything out of it let it be this:

In a world increasingly dominated by centralized frontier models, sovereignty becomes mandatory.

The history of computing keeps returning to the question of where the work happens and who controls it. Shared compute gives communities another way to answer that question for themselves.

As explored in this essay: A community can operate its own relay, keep its conversations and shared history, build agents around its needs, and contribute the machines those agents use. As the technology improves, more of that becomes practical for more people.

Someone maintains the relay. Someone contributes compute. Someone builds an agent that helps new members get started. Someone else develops a plugin or a dedicated device. Each contribution expands what the community can do together.

Think of that as shared sovereignty: an agent harness that lets you retain control over what you contribute while building capabilities you can use together.

There are endless possibilities within that arrangement. Communities could support their own background agents, pay members for useful capacity, share models with neighboring networks, or build services that sustain the people operating them. They would have more room to decide how those systems work and how their benefits are shared.

That is the kind of sovereign network we’d like to see people build, thats the kind of sovereignty we are building for ourselves: one where the people creating the knowledge and doing the work can also own, operate, and shape the infrastructure that supports it.

As always please feel free to offer us feedback, critique or suggestions. Can't wait to see where we can take this.

$cat tags
$