What we have built and what comes next
This page shows what works in our lab today, what we have measured and what we are building next.
Built and tested
Last checked on 11 November 2026.
| Part | Stage |
|---|---|
| Two waitlists with separate email choicesThe sign-up asks you to confirm your email address, gives you a separate choice for each kind of email, and lets you unsubscribe or delete your data. | On this site |
| A coordinator and three node programsThe node programs register with the coordinator, check in regularly, run only tasks from an approved list and stay inside processor and memory limits. | Built in the lab |
| One calculation computed by three partiesThree programs carry out a small calculation on split numbers with secure multi-party computation. Only the program that supplied the numbers gets the result, and an automatic check confirms it. | Built in the lab |
| Small local model benchmarkWe timed Qwen3-0.6B, a small, openly licensed AI model, once on one of our computers with a made-up prompt. This test isn't private, and we keep its figures apart from the three-party results. | Measured once |
| Reward bookkeeping testA test ledger books each finished lab session once, with one customer cost entry, three contribution entries and three pending earnings. A retry never books a session twice. Every entry is marked “simulation, no monetary value”. | Built in the lab |
What comes next
One AI request across three computers
A small language model will answer one request while each computer holds only its piece. We'll publish how long it takes.
A Windows program for invited testers
The first testers will come from the compute contributor waitlist.
An independent security review
It comes before anyone sends confidential data.
Paid pilots
Prices, rewards and payouts in euros come after the tests.
The method, with real numbers
Plan
This is a worked example with made-up numbers. Nothing like this runs for customers yet.
- You ask the coordinator for a session. It picks three computers owned by different people. It never gets your number.
- Your device splits 42 into three random-looking pieces that add up to 42 when you count modulo 10007. 6311 + 2950 + 788 = 10049, and 10049 − 10007 = 42.
- Each piece goes straight to one node. 6311 goes to A, 2950 to B and 788 to C. The coordinator isn't on that path.
- Each node works on its own piece. Here the job is “multiply by 3”, so A gets 8926, B gets 8850 and C gets 2364, all modulo 10007.
- The nodes send their results back, and only your device adds them up. 8926 + 8850 + 2364 = 20140, which is 126 modulo 10007, and 126 = 3 × 42.
Measurements
Measured
We measured the math job on 3 November 2026.
We measured the local model on 4 November 2026.
The job is a small calculation done with secure multi-party computation. Three parties multiply a 2×3 matrix by a 3×2 matrix and then apply two non-linear functions, the rectified linear unit and the sigmoid. They do all of this on secret shares of synthetic numbers. It's not an AI model. We ran all three parties ourselves on one computer, so these results don't show how it behaves between separate owners, over the internet or with a party that cheats.
| Run | Result | Largest error |
|---|---|---|
| On one computer, with 2×3 and 3×2 matrices (13 inputs, 8 outputs) | Passed | 9.995 × 10−6 |
| On one computer, with two 16×16 matrices (513 inputs, 512 outputs) | Passed | 1.975 × 10−5 |
| In our lab, with three agents working through the coordinator on the same computer | Our own client program reported that it passed. The coordinator never sees the result, so it can't check it. | 9.995 × 10−6 |
| Measure | Median | 95th percentile |
|---|---|---|
| Time the first party spent computing on the shares | 0.042 s | 0.068 s |
| Time the first party's engine took to start up | 0.82 s | 0.86 s |
| Whole run from start to finish, with the three parties and the client each in its own container | 2.78 s | 3.46 s |
| In our lab, time from asking the coordinator for a session until all three parties were ready | 0.95 s | 2.90 s |
| In our lab, time the first party spent computing on the shares | 0.052 s | 0.059 s |
| Data each party sent per runThe preparation, which is the offline phase, took 345,632 bytes, and the online phase took 128,576 bytes. All three parties together sent 1,422,620 bytes. | 474,208 bytes in 145 to 147 rounds | |
| In our lab, data each party sent per runThe lab sends fewer bytes because it prepares in smaller batches of 1,000 instead of 10,000. | 373,792 bytes in 157 to 171 rounds | |
| Added round-trip delay | Time the first party spent computing on the shares | Whole run from start to finish |
|---|---|---|
| +20 ms | 1.66 s / 1.66 s | 7.17 s / 7.84 s |
| +80 ms | 6.64 s / 6.71 s | 15.07 s / 16.02 s |
| +150 ms | 12.48 s / 12.49 s | 24.67 s / 26.37 s |
Each round of messages between the parties has to wait for the delay, so the time grows with it.
How we ran it
We used MP-SPDZ 0.4.4 and its replicated-field-party.x program, which does replicated secret sharing over a 128-bit prime field (Araki et al., 2016). The security model is semi-honest, honest majority and non-colluding. It holds if every party follows the protocol and no two of them pool what they hold. The privacy mode label is experimental-mpc-math.
The computer had an 11th Gen Intel Core i5-1135G7 @ 2.40GHz processor. It ran Ubuntu 22.10 under version 2 of the Windows Subsystem for Linux, which had 6 logical processors and 11.7 GiB of memory. We used Docker Desktop with Docker Engine 29.9.2. In the one-computer and delay runs, each party's container was limited to one processor and 512 MiB of memory. In our lab each party's task was capped at one core and 1024 MiB of address space, and all three shared the computer's first logical processor. This affects the lab's times.
Each set of 30 runs started only when the computer's load average over one minute was at or below 1.0. The 95th percentile is the 29th of the 30 sorted values. The byte counts are bytes sent, because the engine doesn't report the bytes it receives.
With 16×16 matrices, each party sent 22.5365 MB per run, and all three together sent 67.6094 MB. These are the engine's own figures, and it counts 1 MB as 106 bytes. They come from two single runs. There's no 30-run measurement at that size.
Our repository is private, so you can't open these automated test runs or the raw result files yourself.
A separate test of a small AI model on one computer
We also timed a small AI model, Qwen3-0.6B, on one of our computers. It's openly licensed, and we gave it a synthetic prompt. It's a plain reference point for our research, and a separate test from the math job above, so don't compare the two sets of numbers. Nothing here is private, because the computer sees the prompt and the answer. We ran it once, and no automated test repeats it. The computer was busy with other work at the time, so treat the figures as rough. We didn't measure how much energy it used.
| Measure | Median | 95th percentile |
|---|---|---|
| Wait for the first token of the answer | 5.10 s | 5.54 s |
| Speed of the answer once it had started, in tokens per second | 22.9 | not shown |
| The engine's own speed test, llama-bench, run 30 times without a server or a prompt, in tokens per second | 29.7 | not shown |
How we ran the model
We used llama.cpp v0.8.0 on the computer's processor, with Qwen3-0.6B in the version labelled Q8_0 (licence Apache-2.0). The prompt is made-up text, the same every time, and the model always picked its most likely next token, so we measured speed, not the quality of the answers. The privacy mode label is experimental-local.
The computer had an 11th Gen Intel Core i5-1135G7 @ 2.40GHz processor. It ran Ubuntu 22.10 under version 2 of the Windows Subsystem for Linux, which had 6 logical processors and 11.7 GiB of memory. No graphics card was used. The run started only when the load average over one minute was at or below 1.0, but other programs kept running. During the requests shown, they used 10.0 % of the computer's processor time.
The 95th percentile of the wait is the 95th of the 100 sorted values. For speed we show only the median. Energy isn't measured, because the computer had no power meter attached. Our repository is private, so you can't open this run's files either.
Limits of these results
We ran every test ourselves, on our own computers, with made-up numbers. All three parties ran on one computer, so the tests check the calculation and not yet privacy between different owners. The method assumes that the three parties follow the rules and do not share what they hold. No AI model has run this way yet, and no independent security review has been done. We don't accept private or sensitive data in any test.