From Renting Minds to Sharing Them

Abstract

Today, to use a frontier-class mind, you rent one. You send your thoughts to a company's datacenter, it thinks, it meters the answer, and it keeps the right to raise the price or close the door. The leap in our first white paper was to send meaning directly, agent to agent, with no platform in the middle. This is its companion, one layer down. The leap here is to share the thinking itself: the machines that people who trust each other already own, a gaming GPU here, a Mac Studio there, pooled into one network that routes work between them, so a small community can reach near-frontier intelligence without renting it from anyone.

We call the mechanism agentic dispatch. We build it on Surfaces. And we engineer every layer of it toward one horizon, the Canvas Mesh, where many small machines finish a single thought together. The point is not to beat the incumbents at their own game. The point is that the intelligence a community runs on should be owned by the community, and that ownership should cost a power bill, not a platform's permission.

This is a companion to From Stacks to Semantic Mesh, which makes the case for sending meaning directly. That paper is about the message; this one is about the mind that answers it.

The Why: Sovereignty as the Point

Every frontier AI you can use today is rented, and rent has terms. The model lives in someone else's building, behind someone else's billing, under someone else's content policy and someone else's decision about who gets access next quarter. That is not a conspiracy, it is an architecture, and the architecture has a direction: capability concentrates, and the people who depend on it hold none of it.

The Commonwealth Charter names this in §2.1, decentralization as mission: not a political preference but a counter-force, systems that move capability toward distributed ownership instead of reinforcing the incumbents. And §2.2, sovereignty over dependence: local and user-controlled is the default, cloud is opt-in, because frontier access can change without warning.

Read that last clause again and notice it is not paranoia, it is a Tuesday. Prices change. Terms change. A model you built a tool on is deprecated. An account is suspended. The question a sovereign community asks is not "is the rented model good enough," it is "what happens to us the day the landlord changes the locks." The answer we want is: nothing, because we own the building.

And here is the honest anchor, the reason this is worth a weekend and not just a manifesto: the intelligence we are pooling has somewhere real to go. Under the helpfultech.org umbrella, this compute serves accessible, public-benefit tools, the kind that help a Deaf musician perform, or a senior who needs a trustworthy second opinion, or a neighbor who cannot afford a subscription to think clearly. Pooling compute is not decentralization for its own sake (§2.8, the greater good is the ruler, not the constraint). It is how a community affords to help its own people without renting the ability to help from a company that could stop selling it.

The How: Route Work, Not Weights

There is exactly one hard rule in distributed inference, and every honest attempt runs into it. A language model thinks one token at a time, and each token depends on the last. If you split a single model across machines, every token has to cross the network between them, and the internet's round-trip time turns a fast model into a slideshow. People have tried this seriously, with real optimization, and the conclusion is consistent: sharding one model's weights across the public internet is a toy.

The networks that survived do the opposite. They keep a whole model on each machine and route whole units of work between machines. Nobody's request is split mid-thought. Instead, a coordinator hands your task to a member's node, that node thinks with a model it holds entirely, and the answer comes back. It is the difference between mailing one sentence of a letter to each of eight houses and hoping they assemble it in time, versus handing the whole letter to the one friend who is free. This is the shape of every serving network that lasted, and it is the shape of agentic dispatch.

On Surfaces, a member's machine runs a connector that dials outbound to the coordination hub. The machine opens the connection; the hub never reaches in. That single choice does a surprising amount of work. A machine behind a home router joins with no port to open, no firewall to weaken, no mesh VPN to install, and no coordinator that has to hunt for it. The hub stays outbound-only and content-blind, exactly as our first paper described the mesh, and the member's node keeps its own cryptographic identity, a key it generates on-device and we never hold.

A unit of dispatched work is a Work Card: a small, signed record with a title, a done-condition, an owner, and a result. It is not a chat message that scrolls away. It is a ledger entry, cryptographically signed by whoever authored it and hash-chained so it cannot be quietly rewritten. When your node finishes a task, the result closes the card, and the close is signed too. Accountability here is not a dashboard we ask you to trust. It is the data structure.

Here is what a dispatched thought looks like on the wire:

{
  "card": "task",
  "title": "Summarize the intake call for the Senior Support helper",
  "doneCondition": "A 5-line summary with next-step flagged, no PII beyond first name",
  "riskTier": "T1",
  "owner": { "type": "agent", "id": "myles-studio" },
  "trust": { "vouchedBy": "helpfultech-sphere", "capability": "draft", "revocation": "clean" },
  "result": null
}

Read it as the anatomy of one dispatched task. Three properties carry the design, the way five properties carried the Semantic Transport Layer in our first paper:

• Trust-gated: every task carries who is asking and what they are allowed to do. Trust is a web, earned and lost, not an account handed out at signup.
• Outbound-only: nodes speak, the hub listens. Sovereignty is the default, not a setting.
• Blast-radius-scoped: every task is classified by how much damage it could do, and the dangerous ones stop for a human before they run.

Contrast the old picture with the new one, the way our first paper set the switchboard beside the mesh:

The Canvas Mesh: Why We Build It This Way

Agentic dispatch routes whole tasks. That is the coarse version of a finer idea, and we design the coarse version so the fine one is a swap, not a rebuild.

Picture a machine drafting a whole answer with a diffusion model, a kind of model that writes a passage all at once and then refines it, and that knows, word by word, where it is unsure. Now send only the unsure spans to a stronger node to repair, and stitch them back in. That is the Canvas Mesh: the same dispatch loop, but the unit is a span of a single answer instead of a whole task, the thing crossing the wire is a few words and a confidence map instead of megabytes of machinery, and the round-trip is paid a handful of times per passage instead of once per word.

This is the reason we build every layer the way we do, in one sentence: the connector, the Work Card, the dispatch verb, are all shaped so that the day we point them at spans instead of tasks, and diffusion models instead of chat models, almost nothing has to change. We are laying track toward a station we can already see. Nobody has built distributed diffusion inference yet, which makes this a real contribution a small community can make, not a race we are late to. Our honest confidence split matches our first paper's: high on the direction, medium on the timeline, low on the exact protocol form.

What It Reshapes

State it plainly so it cannot drift: we are not building a cheaper API. We are building the substrate for a community to own the intelligence it depends on, so that the ability to help the people it serves cannot be revoked, repriced, or surveilled by anyone outside it.

Is It Worth It?

Ask it plainly, because a peer evaluating this will: the best open model you can run is not the best model in the world. On the public leaderboards the strongest open weights sit a few points behind the strongest closed ones, and further behind on the hardest reasoning. So why pool machines to run something that is, today, second best?

Three honest answers.

First, "a few points behind" is not what it used to be. On coding and many everyday tasks the open models have caught or passed the closed ones, and the gap that remains is months, not years, and closing. You are not betting on a laggard. You are betting on a fast field where the open frontier runs a quarter behind and gaining.

Second, a pool is not one model. When several member nodes answer the same hard question and a judge synthesizes them, the panel beats any single member's model, and beats some closed frontier models too. This is not a hope. It shipped as a product this year and measured out ahead of the solo frontier at half the cost. Pooled cheap intelligence, judged well, is its own frontier.

Third, and most important: "worth it" measured against a benchmark is the wrong scoreboard. Measure it against the mission. A rented model that scores two points higher does not help a community that cannot afford it, cannot govern it, and can be cut off from it. A pooled model the community owns, that serves accessible public-benefit tools, that costs a power bill and answers to a board of the people it serves, is worth more than a benchmark point, because it is still there the day the benchmark leader changes its terms. The measure of success, as our first paper put it, is how little you need the system at all: how much of your community's thinking already runs on hardware your community holds.

Safeguards: Privacy, Security, and the Limits We Admit

A network you would ask a friend to join has to answer the hard questions before they do. Here are ours, including the parts we have not finished.

Privacy, by compartment, not by promise. The coordinator is content-blind: it routes work without reading it. Sensitive work is pinned to trusted nodes, so a prompt about a struggling senior never travels further than the people already inside that trust web. A platform turns "this person is lonely on Tuesdays" into ad inventory; the mesh keeps the same fact where it belongs, with the people it describes (§2.7).

Security, by design, not by trust. Nodes dial out and the hub listens, so there is no inbound port to attack. Each node carries a cryptographic identity it generates and we never hold, so there is no account to phish and no central key to steal. Trust is a vector, earned through observed behavior and lost quickly on leakage, scoped by sphere and capability, with no actor trusted universally by default. A node that misbehaves is demoted or killed, and the kill is a signed, auditable event.

Safeguards, by blast radius. Every task is classified from T0 (read-only) to T4 (destructive or privileged). Read-only work runs freely; external writes and destructive actions stop for a human before they execute. The classifier is a deterministic rule, not a vibe, and a node can only ever over-state its own risk level, never hide it.

The limit we admit. Here is the thing a serious peer will find, so we say it first: a node that computes a piece of your work can see that piece. We do not yet have cryptographic blindness that lets a stranger's machine help without seeing what it helps with. So today this is a network for people who are aligned, not anonymous, which is exactly the closed, trusted membership our architecture already assumes, and we lean on cross-checking (the same task sent to two nodes and compared) to catch a node that lies. The paths that would relax this, confidential-compute enclaves and partial-context repair, are on our watch list, named, not pretended-solved. A safeguard we describe but do not enforce is not a safeguard. We would rather show you the edge than paint over it.

Roadmap & Call to Participate

Near term. A few machines, a shared room on Surfaces, and a prompt that a member's node answers and returns. Crude, real, this month, on rails that already exist.

Medium term. A clean dispatch verb, trust-gated and blast-radius-scoped, member machines as first-class worker nodes, and the panel that turns three cheap models into one good answer.

Long term. The Canvas Mesh: many machines finishing one thought, language on the wire, the open frontier arriving a quarter late and running on hardware we own.

The call. This is a commonwealth project, which means it wants co-builders, not customers. If you are running a GPU that idles most of the day, sitting on a Mac with more memory than your work uses, building local-first or sovereign infrastructure, or simply tired of renting the ability to think from companies that meter it: there is a node here for you. Bring a machine. Run a node. Break the trust model and tell us how. Help us measure the only question that matters, whether a community can own its own intelligence and use it to take care of its own people.

The compute is ours. The dispatch is how. The commonwealth is who it is for.