Where it stands · November 2026
A two-owner pilot, and what it does today
The manifest says what the federation stands for. This page says what its software does now, how, and how far each part has been tested. "Live" means running between the pilot's two nodes, not proven across a large federation.
Current implementation status: two-node pilot
| Part | State | Tested |
|---|---|---|
| Two nodes (NVIDIA DGX Spark), each lending model capacity to the other | live | in daily use |
| Links with pinned certificates, confirmed by the owners | live | in daily use |
| Credits recorded on both sides, compared automatically | live | in daily use |
| Containerised tasks run for a partner | live | since November 2026 |
| Charter version 1, accepted and signed by both owners | live | — |
| No link without each owner's signature on the charter (model requests, tasks, pairing, relays) | live | since 21 November 2026; both pilot owners have signed |
| Refusals under the charter, on model requests: every new instruction judged before it runs | live | since 21 November 2026, on both nodes |
| Refusals under the charter, on tasks: judged before they are accepted, by purpose or likely direct effect | live | since 21 November 2026 |
| Owner overrides of a refusal, signed with the owner key (never for absolute points) | live | on simulated nodes; none used yet |
| Relays (several hops), nodes behind NAT, discovery listings | built | on simulated nodes only |
| Warnings between partners (silence, models down, certificates near expiry) | live | in daily use |
| Lab installer and in-place upgrades | built | on test benches |
| Charter version 2 | under the owners' review | — |
Charter checks and refusals
- Signing is required: a node works only with partners whose owners signed, with their owner keys, a charter version its own owner signed. Unsigned, a node gets no work and gives none; this cannot be switched off.
- Refusals are on on both pilot nodes, since 21 November 2026. Every new instruction a person writes in a model request is judged before it runs, by the node that runs it, with its own model given the charter's text; the verdict is kept for a day. A refusal answers in the client's own format, names the principle and the point, and gives a check id; the work does not run and uses no slot.
- If the judge does not answer within 30 seconds, the request is refused, a partner's always and a local one by default: nothing runs unchecked.
- Overrides: for points that are not absolute, an owner may mark a refusal on their own node as wrong, signed with their owner key. Overrides are counted and visible to partners. Absolute points can never be overridden.
- Tasks are judged before they are accepted, by their purpose or their likely direct effect: who sent them, their name and declared purpose, and what they would run (every image, working directory and command, and the scripts and data sent inline). A task that says it backs up files while its script encrypts them for a ransom is refused. A refused task is never stored or run; if the judge does not answer, a partner's task is refused.
- What the task check cannot see: data a task fetches by its hash, and what the image's own code does beyond its command. A task could still hide its effect there; what bounds it then is its sandbox (below) and the owner's choice of which images may run.
- Measured: on test sets of harmful and allowed requests, every harmful one was caught and no allowed one flagged. On one node's real work, 0.29% of requests were flagged wrongly. Judging adds well under a second to a request.
- Known weakness: the judge sometimes files a request under a broader point than the most specific one; a request about a nerve agent was refused under "kill or seriously injure people" rather than the absolute "weapons of mass casualty", so an owner could override it. Making the judge prefer the most specific point is the next step.
- Not yet: nodes may run different models, so agreeing on the charter's wording does not by itself make the checks agree. Each node should publish its checker's model, configuration and test results beside the charter version it accepted.
Trust and privacy
- A partner sees the work it runs. Its owner operates the machine and can inspect what is processed there. Send work to another owner only when you trust them with its contents.
- Agent memory stays home. Work a node runs for a partner is not added to that node's persistent memory: no summary of it is stored.
- Operational records (counts of tokens and compute time, timings, charter check results) are kept by each node under its owner's own retention.
- Nothing is published or sold; the federation has no place to publish to.
Tasks for a partner
A node can run containerised tasks for a partner, through a subset of GA4GH TES. The receiving owner decides which partners may send tasks and which images may run, each named by its SHA-256 digest.
- No network, unless the receiving owner allows it for that partner.
- A read-only filesystem, with a small temporary area; no added privileges; all Linux capabilities dropped.
- Limits on CPU, memory, processes and running time, set by the receiving owner; a GPU only where the owner allows it.
- Inputs and outputs are named by their SHA-256 and stored only when the content matches its name.
- Images are never fetched by the federation: each owner pulls or loads them and allows them by digest, so private images need no public registry.
Credits
- What is counted: for model requests, prompt and generated tokens (a generated token weighs 130 prompt tokens), times a weight per model or model family. For tasks: CPU, memory and GPU seconds, with provisional weights.
- A task counts what its own code used, also when it fails or is cancelled; never what a node loses through its own fault.
- Between two nodes only. Each pair keeps its own record on both sides; there is no global balance, and credits cannot be passed on. The two records are compared automatically and a lasting difference is reported.
- What credits buy: order, not capacity. A lending node serves first, among the requests waiting for it, the partners it owes the most. It promises no free slot.
Relays, NAT and discovery
- Relays: a request can reach a node through partners, each hop only with its owner's signed consent. It is encrypted end to end, from the sending node to the node that runs it: a relay forwards it but cannot read the request or the answer. A relay sees which nodes talk, the sizes and timing of the traffic, and the signed receipt (the model and token counts).
- Nodes behind NAT keep a channel open to a partner their owner chooses, and serve that partner's requests over it.
- Discovery listings (a contact and a region, signed by the owner) travel inside the nodes' own signed cards, passed from partner to partner up to three hops. There is no directory server. A listing introduces; it never authorises access or creates a link.