From this demo to a real open model.
What would change, and what would not, if this fine-tuned a model like Qwen or Mistral.
Could this fine-tune a real Qwen or Mistral model?
The language-model demo on the live demo page is a deliberately tiny stand-in: a two-layer transformer that writes the digits of a sum, rewarded when the sum is right. It uses the same reinforcement-learning recipe (GRPO) that open models such as Qwen and Mistral are tuned with, and every matrix product in it runs on the volunteer browsers with proofs. A real model would work the same way, with some changes and a much bigger bill.
What changes for a real model
The base weights are public. An open model’s weights are not a secret, so each volunteer downloads and caches them once. Only activations, which come from the private prompts and the model’s own answers, are split into shares. With one secret side, the products are linear in the shares, so a given privacy level needs fewer nodes and less arithmetic than the demo’s.
Train adapters, not the whole model. Low-rank adapters (LoRA) are a small fraction of the parameters. Only they are updated and sent around, and they can be merged into the base model at the end.
Answers are the expensive part. In GRPO most of the work is the model writing many candidate answers per prompt, plus scoring them against a frozen reference. The reward check itself, such as a maths answer or a unit test, is cheap and stays on the server.
Browsers need a GPU. Real-size models need WebGPU nodes. Processor-only WebAssembly is fine for the demo but far too slow for billions of weights.
Rough size of the job
One GRPO step with 64 prompts, 8 answers each and 256 tokens per answer is about 131,000 tokens, or roughly five forward-pass equivalents of work (writing, scoring against the reference, and learning), split into 3 shares. These are ideal back-of-envelope figures with 1,000 volunteers; real networks, memory limits and stragglers make them worse.
| Model | Multiply-adds per step | Browser processors (1 GMAC/s each) | Browser GPUs (100 GMAC/s each) |
|---|---|---|---|
| 0.5 billion parameters | ≈ 1 × 10¹⁵ | ≈ 16 minutes | ≈ 10 seconds |
| 7 billion parameters | ≈ 1.4 × 10¹⁶ | ≈ 3.8 hours | ≈ 2.3 minutes |
So a small open model tuned by a large GPU-equipped volunteer pool is plausible, while a processor-only pool is not. The privacy, proof and receipt machinery on this page does not change with model size; the speed does.
What “opt-in” means here
No browser joins until its owner agrees in a plain-language screen that says what runs. The owner picks the number of threads and how hard to work, can have the tab step out automatically when it is in the background or on battery, and can stop it with one click. The server never learns anything about the device beyond how fast it answers.