The whole fab, on one page.

Every graphics card is a supply chain: someone designed the chip, someone etched it, someone made the memory. The fab turns time on your GPU into small, real slices of those companies, as tokenized stocks on Robinhood Chain. You run a workload in a browser tab, the fab scores it, and a public treasury pays you in the tokens of the companies that built your card.

The same GPUs also answer prompts: small open models in miners' tabs and on headless nodes, behind one OpenAI-compatible endpoint. That is the other half of the fab, and it is what the treasury is for in the long run: paid work funding the rewards.

Open fabrwa.xyz/fab, pick an instrument and a length, and press begin. Your tab keeps the GPU busy for the whole run and reports the sustained score. Nothing is installed and nothing leaves your machine except the score.

FAB-06 is the first instrument the server checks rather than trusts. The server issues the seed; every eight seconds the tab commits the result of every one of its million lanes in a Merkle root, the server then names sixteen lanes and recomputes them from the seed. A client that did a fraction f of the work passes with probability f to the sixteenth, and the score is computed by the server from the checkpoints it verified, not from a number the client reports. Scored and listed like every other run; paid once a week of runs has calibrated its ceilings.

Runs are 15 min, 30 min, 60 min. A run has to come back after its chosen length, once. One IP gets 4 runs an hour.

The first run is a free trial: it shows you your score and is not paid. Paid runs need a mining pass, a signed message from a wallet holding at least $30 of $FAB. The holding is checked when the run starts and again when it finishes, and bigger holders mine on more GPUs at once:

The result screen says how long the tab spent hidden during the run and flags it past 2% of the run, because browsers throttle background tabs and a throttled GPU scores lower. The page also warns before a reload throws a running run away. Scores are capped per vendor family (nvidia 130 TF, apple 30 TF, amd 90 TF, intel 35 TF, qualcomm 8 TF, arm 8 TF) so a card cannot report more than its family can do.

A verified run earns $0.10 plus $0.0009 per verified compute unit, times your tier, times the governor rate. One VCU is 40 tflop of math, 800 GB of memory traffic, or 18 billion paths traced.

The reward is paid in the tokens of the companies in your card's lineage. The server sets the split from the vendor it recognises; an unidentified card gets the generic split:

Runs settle every 6 hours, 4 times a day. At each settlement the fab signs one voucher per wallet, and you redeem it on chain yourself. The governor scales the rate so payouts land at 1% of the vault per day, never below ×0.1, and each stock token has its own cap, so no epoch can drain the vault however many people mine.

A contract on Robinhood Chain that holds tokenized stocks and pays vouchers out of them. Anyone can deposit against a ticker with a memo, and every deposit shows on the funding ledger. What it holds right now is read from the chain on fabrwa.xyz/treasury.

The Samsung slice is paid as EWY, a Korea ETF, because Samsung has no stock token on the chain yet. Explorer: robinhoodchain.blockscout.com.

$FAB is the launch token, on Pons v2. Holding at least $30 of it is what turns a scored run into a paid one, and holding more lifts your tier: more GPUs at once, a higher multiplier. It is not what you are paid in. Rewards are stock tokens from the treasury.

The contract address is on the home page, with a copy button and an explorer link. Copy it from there, not from a message.

• A run starts with a server-issued token and can be completed once, only after its chosen length has passed.
• The score is capped per vendor, so a card cannot report more than its family can do.
• The free trial is one per IP, counted as a salted hash. Every other run needs a pass, and the pass wallet must still hold $FAB when the run finishes.
• The payout split is set by the server from the reported lineage. The browser has no say in it.
• No epoch can pay out more than a small share of the vault, and each stock token is capped separately.
• Every voucher is signed by the settler and redeemed on chain, where anyone can read it.
• FAB-06 runs are spot-checked: the server issues the seed, the tab commits every lane in a Merkle root every eight seconds, and the server recomputes sixteen lanes it chose after the commit.
• Miner answers can be replayed on a second GPU on demand; node answers are replayed on another node running the same model build.

• On FAB-01 to FAB-05 a modified client can still report a score it did not earn, up to the vendor ceiling. FAB-06 is the first instrument where it cannot; the same checks come to the others.
• Work served by a headless node is not paid. Node answers are now cross-checked between nodes running the same model build; the pay switch comes after a week of that data.
• FAB-06 is scored and spot-checked but not paid, until a week of pass runs calibrates its ceilings.
• The treasury contract is owned by the settler key, not a multisig. That is the last item on the trust list.

The open dataset carries a verified column for every run, and the roadmap lists these items with a date when they ship.

One base url. Point any OpenAI client at it and a real GPU answers. Small open models run in miners' browser tabs and on headless nodes. Frontier models run on their maker's API with your own key. Every answer says who wrote it.

https://fabrwa.xyz/api/v1

CORS is open on all of them. Call them from a browser.

no header at all

authorization: Bearer fab_...        (also accepted as  x-api-key: fab_...)

x-provider-key: sk-...               (also accepted as  authorization: Bearer sk-...,
                                        x-anthropic-key, x-deepseek-key)

The fab holds no provider key of its own, so nothing here can bill the operator.

curl -X POST https://fabrwa.xyz/api/v1/chat/completions \
  -H 'content-type: application/json' \
  -d '{"model": "smol-135m",
       "messages": [{"role": "user", "content": "What is a semiconductor fab?"}]}'

{ "id": "chatcmpl-...", "object": "chat.completion", "model": "smol-135m",
  "choices": [{ "index": 0, "message": { "role": "assistant", "content": "..." },
                "finish_reason": "stop" }],
  "usage": { "prompt_tokens": 19, "completion_tokens": 96, "total_tokens": 115 },
  "fab": { "served": "miner", "gpu": "APPLE M2 PRO", "tokens": 96, "ms": 3210,
           "prefillMs": 640, "job": "...", "poll": "/api/v1/inference/..." } }

The fab object is the part OpenAI does not have: which GPU answered, how many tokens it wrote, how long it took with prefill, and the job you can poll. model names the model that actually wrote the answer, so asking for an alias tells you what served it. usage counts prompt tokens on the GPU that answered. Errors come back with a string code, and a timeout says whether the job was still queued or already running.

The fab object is the part OpenAI does not have. It names the GPU that answered, or the provider, and how long it took.

A prompt waits in a queue until a GPU with those weights takes it. If none does within 45 seconds the call returns 504 with the job id and a poll url, and the prompt stays in the queue.

curl -X POST https://fabrwa.xyz/api/v1/chat/completions \
  -H 'content-type: application/json' \
  -H 'x-provider-key: sk-...' \
  -d '{"model": "claude-opus-5",
       "messages": [{"role": "user", "content": "hi"}]}'

Send "stream": true and the answer arrives as server sent events, in OpenAI chunk shape, ending with data: [DONE]. Frontier models stream token by token from the provider. Open models stream what the miner or node has decoded so far, posted about once a second, then the finished answer as the source of truth. The last chunk carries usage and the fab object. Keep alive comments arrive as lines starting with a colon while the prompt is still waiting for a GPU.

Open models decode greedily, so the same prompt gives the same answer and a second GPU can recheck it. There is no temperature to set.

Any miner-served answer can be re-run on a second GPU on demand: POST /api/v1/inference/{job}/verify with the job id from the fab object, then poll the job for verified and verifiedBy. Free, ten checks per hour per IP. A node answer is replayed only on another node running the same model build, so a node that did not declare its build cannot be checked. Frontier answers are never cross-checked.

GET /api/v1/models returns every id in OpenAI list shape, with a fab block saying who serves it.

A model with no GPU holding it right now still accepts prompts. They wait in the queue.

These are accepted and dropped, not rejected: temperature, top_p, stop, n, seed, tools, tool_choice, response_format. Only model, messages, stream, max_tokens and max_completion_tokens change the answer. Tool calling and json mode are not implemented.

A fab key lifts the hourly limit and the answer length on the open models. It is not needed for frontier models: those run on your own provider key.

1. 01GET /api/v1/keys. It answers with the pay to address, the minimum, and how many credits a dollar buys right now.
2. 02Send at least 0.001 ETH on Robinhood Chain to that address.
3. 03Sign the message below with the wallet that sent the ETH. The signature proves the payment is yours, so nobody who sees the transaction can claim it first.
4. 04POST /api/v1/keys with {"txHash": "0x...", "signature": "0x..."}. The fab checks both on chain and answers with the key, once. It is not stored anywhere you can read it back.
5. 05Send it as authorization: Bearer fab_... on every call.

The message to sign, with your own transaction hash in it:

fab / use a payment

I sent this transaction and want to use it for an inference API key.

0x<your transaction hash>

Signing sends no transaction.

$1 of ETH buys 1,000 credits. A prompt costs 1 credit on the smallest model and up to 10 on the biggest a tab can hold. GET /api/v1/keys/me with authorization: Bearer fab_... returns what is left.

That ETH is swapped into stock tokens in the treasury, which is what pays the miners answering your prompts.

The render instrument, FAB-03, is a path tracer. A job buys frames from it: send at least 0.002 ETH on Robinhood Chain to the fab address, sign the payment message with the wallet that sent it, and post both on fabrwa.xyz/jobs. 4,000 frames per ETH. A miner running FAB-03 posts one frame every 15 seconds, and the board shows the last 24 as they land.

The ETH is swapped into stock tokens in the treasury, like a key purchase. That is what pays the miner rendering your frames.

A browser tab tops out around 3.5 GB of weights. A machine that holds more can serve the fab's inference queue from its own Ollama, with a wallet that holds $FAB. The client streams answers as it decodes, ships with a checksum, and reads the key from a file so it never lands in shell history.

curl -O https://fabrwa.xyz/fab-node.mjs
curl -O https://fabrwa.xyz/fab-node.sha256 && sha256sum -c fab-node.sha256   # macOS: shasum -a 256 -c fab-node.sha256
npm i viem
ollama pull qwen3:8b
PRIVATE_KEY_FILE=~/.fab/key node fab-node.mjs   # serves every fab model your Ollama has pulled; add --models=qwen3-8b to pick

Every model is served from your own hardware; cloud models are refused. The key signs one message to prove ownership and sends no transaction. Node work is not paid yet: the pay switch comes after a week of cross-check data.

Client 1.2 finds the models your Ollama already has, declares the exact build of each one (tag, digest, quantization), and reconnects instead of exiting when the fab or Ollama is briefly unreachable. Answers are replayed on another node running the same build, and the verdict is stamped on the job like a miner answer's. One status line a minute says what it served and how its answers fared.

Every verified run the fab has paid for, in one file. No wallets, no IPs, no run tokens. Cached for ten minutes.

curl 'https://fabrwa.xyz/api/dataset?format=csv'   # or format=json for json lines

Columns: id, at, instrument, gpu, vendor, arch, country, api, score, unit, vcu, duration, mode, multiplier, tier, epoch, verified.

Rows from the free-trial farm of September 14 are still in the file with verified set to 1, because they passed the checks that existed that night. They are one wallet, RTX 5090, 586 runs in 18 hours, and easy to filter.

run

One session of 15 min, 30 min or 60 min in which your browser tab keeps the GPU busy with one instrument and reports the sustained score.

instrument

One of the six workloads, FAB-01 to FAB-06. Each measures a different thing about the card and has its own unit.

vcu

One verified compute unit. 40 tflop of math, 800 gb of memory traffic, or 18 billion paths traced.

lineage

Who designed the chip, who fabbed it, who made the memory. Read from the adapter your browser reports, and it decides which stock tokens a run pays in.

pass

A signed message, no transaction, that proves a wallet holds at least $30 of $FAB. It lasts 24 hours and it is what makes a run paid instead of only scored.

tier

How much $FAB the passing wallet holds, in four steps. Higher tiers mine on more GPUs at once and every run pays a little more.

epoch

A 6 hour window. Runs pile up inside it. When it closes, everyone in it is paid at once.

voucher

A signed note from the fab saying which tokens you earned and how much. You redeem it on chain yourself.

settler

The fab's own signing key. It signs vouchers for runs that already happened. It cannot sweep the treasury or replace itself: only the owner can. It does decide what each voucher says, so treat it as a hot key until ownership moves to a multisig.

governor

The rule that scales rewards to the vault. It aims to pay out 1% of what the vault holds per day and moves toward that a step at a time.

The only accounts that are fab are t.me/siliconfab and t.me/fabrwachat. Nobody from the fab will message you first, ask for a key, or ask you to send anything.

What the fab keeps about you is on /privacy, and what it can and cannot promise is on /terms.

What changed, and when: fabrwa.xyz/changelog.