COMPUTE, OWNED BY PEOPLE
What do you want
to execute?
AI. Images. Video. Code. Custom containers. One mesh of people's GPUs runs it all — and pays the people who own them.
Underneath: a decentralized mesh of independent GPUs. Jobs route to available hardware, execute in verified environments, and every result comes back with a receipt you can open in the explorer. how it works ↓
Settlement
- Pay per execution
- USDC settlement
- Verified execution receipts
WHAT IS Q0R
A decentralized
compute network.
Jobs are not sent to cloud providers. They are routed to available GPUs across a global mesh of independent machines.
Execution is not reserved — it is opportunistic. The network takes whatever capacity exists right now, uses it, verifies the output, and pays the machine that did the work.
Why it exists
Compute is already distributed. It is just controlled by centralized providers — priced by a rate card, gated by quotas, parked behind sales calls.
q0r exposes the underlying machines directly.
The network
- jobs are matched to GPUs in real time
- execution is verified on completion
- failed runs are retried or rerouted
- workers are paid per successful output
HOW IT WORKS
Execution is
opportunistic.
Nothing is reserved ahead of time. The network uses the capacity that exists at the moment you need it — and routes around whatever breaks.
You submit a job.
A signed request: container, hardware class, verification policy. No reservation, no quota — the job enters the mesh directly.
The network finds a worker.
Matching happens in real time against whatever capacity exists right now — scored on latency, load, and reliability history.
The worker executes and streams results back.
Work runs in an attested environment. Output streams back as it is produced, with a proof attached on completion.
If a node fails, the job reroutes automatically.
Dropouts, thermal throttling, dead peers — all normal. The job moves to another worker and keeps going. Failed runs are retried.
Verified output gets paid.
The network settles per successful result, each epoch, in USDC. Unverifiable work is not paid.
FOR PROVIDERS
Share your compute.
Turn idle GPUs into income.
Most GPUs sit idle most of the day. On q0r, that idle time becomes supply: your hardware earns whenever the network has work that fits it.
Run a lightweight worker
One command installs the q0r worker. It benchmarks your hardware, attests the environment, and joins the mesh — a workstation with one GPU counts just as much as a rack with sixty-four.
Accept jobs automatically
The scheduler routes work that fits your hardware. You set availability windows and a price floor; the worker handles everything else, including failover if you go offline.
Earn for completed execution
Every verified job pays out in USDC at epoch settlement. Utilization, reliability, and response consistency raise your share over time.
# install the worker — benchmarks + attests your hardware
$ curl -sL get.q0r.network | sh
# connect the wallet your rewards settle to
$ q0r wallet connect
# join the mesh and start accepting jobs
$ q0r worker start
Q0R TOKEN
Stake $Q0R. Self-custody.
Your Q0R stays in your wallet. Only stake weight is read by the network.
connect a wallet to stake. your tokens never leave your custody — only stake weight is read by the network.
live staking and settlement activity is on-chain and visible in the explorer — this page describes the model, not the moment.
stake behavior
staking does not unlock features. it changes routing weight.
higher stake → higher trust score → more job allocation.
unstaked tokens have no routing influence.
value flow
compute jobs generate USDC revenue. it splits continuously into:
- provider payoutsper verified output
- staker rewardsUSDC · per epoch
- protocol reservegoverned on-chain
- $Q0R buyback + burnper execution batch
burn is not scheduled. it happens when compute happens.
slashing
invalid execution reduces trust: stake reduction, routing weight decrease, possible exclusion from the job pool. failure is part of system behavior.
Q0R is not a utility token. it is a coordination signal for compute execution.
the network runs regardless. the token enforces trust between machines that do not know each other.
DEVELOPERS
The network is
an API.
Everything the explorer shows, the protocol exposes. State is free to read; execution is a signed request away.
Permissionless APIs
Any application can submit workloads. No accounts to provision — a signed request is the only requirement.
Verifiable execution
Every job returns a proof. Results are checkable by anyone, from genesis.
Streaming telemetry
WebSocket firehose for job states, provider health, routing, and capacity.
SDKs
Typed clients for TypeScript, Python, and Rust track the protocol release-for-release.
Subgraphs
Indexed history for every job, provider, and epoch since deployment.
ONE PROMPT AWAY
Execute
something.
Ask a model a question. It runs on someone's idle GPU, streams back verified, and hands you a receipt that proves the work — in seconds, for a fraction of a cent.
permissionless · pay per execution · every job leaves a receipt