What it does · November 2026

One owner's AI node, and a federation of them

Each node is a complete AI stack its owner runs for their own people. Linked by agreements between owners, nodes lend each other capacity, run each other's tasks, carry each other's messages and watch over each other, under a charter every owner signs.

Live means running between the pilot's two nodes. Tested means built and passing on simulated federations of two to four nodes, but not yet used between real ones: the pilot has only two. Where it stands has the details.

The node

Models on the owner's GPU live

A coding model, a vision model, an embedding model and a safety model, served on the node's own NVIDIA DGX Spark. Nothing leaves the machine unless the owner lends it.

One endpoint for agents live

Agents send ordinary chat requests to one address. A router picks the model, a scheduler shares the slots by priority and per-project limits, and a conversation stays where it started.

Memory that stays home live

Facts, conversation turns, documents, an entity graph and code, each in its own memory. Only what is related is added to a request. Work done for a partner leaves no summary behind.

A dashboard and a gate live

One login in front of every page. The dashboard shows status, projects and limits, live traces, memory, the federation, alerts and tasks.

Checked every day live

A suite of 42 checks measures the whole stack daily. Watchdogs follow the network, the gate and the partners.

Joining, between owners

An owner key live

Made in the owner's own browser and kept on the node only encrypted with the owner's passphrase. It signs every act that is the owner's to make: the charter, consents, endorsements, overrides.

Pairing by voice live

Two owners exchange join cards and confirm their nodes' certificates by voice. Each node pins the other's; there is no certificate authority and no list of members anywhere.

The owner's page live

One page, step by step: the owner key, the release, partners, the charter, the node's key, relays, messages and charter checks.

Keys that change, and warn live

A node can change its key without pairing again: each partner accepts the change. A warning comes 90 days before any certificate expires.

Passing the federation on live

Every node serves its release: the full source, the installer and the images, endorsed by owners with their keys. A newcomer downloads it from a node and checks the endorsements.

A lab installer tested

Sets up a new DGX Spark from a release, with the models pinned to their exact versions, and upgrades it in place later.

The charter, enforced

Signed by every owner live

No node takes part unless its owner signed the charter with their own key. Without it, a node gets no work and gives none.

Refusals before work runs live

Every new instruction in a model request is judged before it runs, by the node that runs it. A refusal names the principle and the point. If the judge does not answer, the work is refused.

Tasks judged by their effect live

A task is judged before it is accepted, by its purpose or likely direct effect: what it declares, and what its commands and inline scripts would do.

Absolute points stay absolute live

The judge lists every point a request matches, and an absolute one decides. An owner may override a wrong refusal on their own node, signed and visible to partners, but never for an absolute point.

A charter that cannot weaken live

A new version must keep every absolute point of the previous one. It takes effect between two nodes only when both owners sign it.

Sharing work, and keeping count

Lending what is idle live

A request that would wait goes to a partner with a free slot for its model, and the answer streams back. A flooded node can ask its partners for more than their usual share.

Tasks for a partner live

Containerised tasks, a subset of GA4GH TES. Each runs without network unless allowed, on a read-only filesystem, within limits the receiving owner sets, from images that owner allowed. Data is named by its SHA-256.

Credits, not money live

Each pair of nodes counts what one gave the other, on both sides, from tokens and compute time. The two counts are compared. A node serves first, among those waiting, the partners it owes most.

Relays tested

A request can reach a node through partners, with every owner's signed consent. It is sealed end to end: a relay sees who talks and how much, never what is said.

Behind NAT tested

A node without a public address keeps a channel open to a partner it chooses, and lends over it.

Finding each other tested

An owner may list their node, with a contact and a region. Listings pass from node to node; there is no directory server. A listing introduces; it never pairs.

Messages, and alerts

Owner to owner live

Messages sealed for the node they go to and signed by the one that sends them. Kept and retried while the other node is away, with receipts, replies and an inbox on the owner's page.

About a task live

Applications can ask about their own tasks, and the answer stays with the task on both nodes.

To someone you have not met tested

A message can travel through relays. If no route is known, the node asks its partners, who ask theirs, up to six hops, to find an owner who receives messages. Only the owner's identifier travels, never the message.

Partners watch each other live

A node gone silent, a model down, a certificate near expiry: its partners notice and tell their owners, encrypted node to node, with no outside messaging service.