QuantumGrid pools idle GPU, CPU, and server capacity from independent providers into a single distributed compute network. Instead of buying a supercomputer, you rent exactly the slice of one you need — and the fees that pass through the network flow back to the people who hold and secure it.
A single company buying its own supercomputer pays for peak capacity it uses a fraction of the time. QuantumGrid inverts that: capacity already exists, scattered across thousands of machines that sit idle most of the day. The network's job is to find it, verify it, and price it.
GPU / CPU / Server owners
Operators connect machines and expose the capacity they are not using. The node agent benchmarks the hardware, assigns it a tier, and takes it online.
Scheduler & settlement
The scheduler places each workload on the cheapest node that satisfies its region, memory, and latency constraints, then settles payment on-chain once the work is verified.
Teams shipping products
Developers request compute by the hour or by the job, or call the inference gateway directly. They pay for usage, not for reserved capacity sitting idle.
Serve open-weight models at production latency
Diffusion pipelines, batch or interactive
Frame-parallel generation across nodes
Render farms without owning the farm
ETL, indexing, and large joins on CPU tiers
Scheduled batch jobs and fine-tuning runs
Node infrastructure, provers, and indexers
Simulation and analysis workloads
Most token models ask you to hold and hope. This one has a revenue line: someone rents a GPU, the job settles, and a fee lands in the treasury. What the treasury does with that fee is the entire model.
Workloads run on the grid and settle in stablecoins or $QGRID.
Every settled job pays a protocol fee into the treasury contract.
The treasury converts its fee share into $QGRID on the open market.
Epoch rewards flow to stakers, providers, the treasury, and the burn.
The split is a protocol parameter, not a policy the team can change quietly — altering it requires a governance vote. Distribution runs once per epoch against whatever revenue actually arrived.
100% of net protocol revenue, per epoch
Paid to wallets staking $QGRID. Distributed per epoch, proportional to stake weight and lock duration.
Paid on top of job settlement to the nodes that actually served the workload. Weighted by uptime and verified output.
Scheduler infrastructure, API gateways, security audits, monitoring, and network expansion.
Market-buys $QGRID and sends it to a burn address, permanently reducing supply as usage grows.
Rewards are a share of revenue, not a fixed rate. An epoch with no jobs pays nothing, and no yield figure anywhere on this site is a promise.
Most GPUs spend most of the day doing nothing. Register the machine, pass the benchmark, post a bond, and the scheduler starts routing paid work to it — with earnings settled per epoch against work the network verified.
Illustrative. Utilisation is an assumption, not a guarantee, and the bond converts at a reference rate of $0.0412 because $QGRID has no market yet.
Whether you are buying compute, selling it, or holding the token that coordinates it, there is one dashboard and one balance behind all of it.
Rent GPU and CPU by the hour or by the workload.
Pick a hardware class, set a duration or a job budget, and the scheduler places it on the cheapest node that meets your latency and region constraints.
An OpenAI-compatible endpoint backed by the grid.
Point an existing client at the gateway and inference is routed across available nodes. Same request shape, usage billed per token.
Register hardware, post a bond, earn on idle capacity.
Install the node agent, pass the hardware benchmark, bond $QGRID, and start receiving jobs. Earnings settle per epoch against verified work.
Stake $QGRID and trace where the revenue came from.
Rewards are shown against the network activity that produced them — not an emissions number — so the yield is traceable to real jobs.
A token with one use is a ticker. $QGRID is the settlement asset, the staking asset, the collateral providers put at risk, the governance weight, and the thing the treasury buys back.
Settle any workload in $QGRID and pay a reduced protocol fee versus stablecoin settlement.
Stake to claim a proportional share of the 60% revenue allocation, streamed each epoch.
Providers post $QGRID as collateral to join. Bad service or manipulated results slash the bond.
Vote on fee parameters, slashing thresholds, emission schedules, and which hardware classes qualify.
The token the treasury buys and burns, tying supply reduction directly to network usage.
Joining the grid means posting $QGRID as collateral, sized to roughly a month of the hardware's gross revenue. Falsified output or sustained downtime slashes part of that bond. It is the difference between a promise and a cost.
QuantumGrid settles on Robinhood Chain — a permissionless, EVM-compatible Arbitrum Orbit L2 that posts to Ethereum and uses ETH for gas. The choice is about the shape of the traffic, not the brand on it.
A busy grid settles hundreds of thousands of small payments a day. That pattern is unusable anywhere fees are measured in dollars, and fine on an L2 with sub-cent costs.
Roughly 100ms soft confirmations mean the scheduler can treat payment as resolved within the lifetime of a short job instead of holding an escrow open.
It is a standard EVM chain on the Arbitrum Nitro stack. Existing wallets, Solidity contracts, and tooling work against it unchanged, and gas is paid in ETH.
Batches post to Ethereum for data availability and final settlement, so the network's own security assumptions do not have to be taken on faith.
QuantumGrid is an independent project. It builds on Robinhood Chain as public infrastructure and is not affiliated with, endorsed by, or operated by Robinhood.
If a question about this model has an uncomfortable answer, it is better read here than found out later.
From compute that people pay for. Every settled job pays a protocol fee, and 60% of that fee is allocated to stakers. If the network serves no jobs in an epoch, there is no revenue that epoch and the reward is zero. This is a revenue share, not a fixed-rate emission.
It is a permissionless, EVM-compatible Arbitrum Orbit L2 with roughly 100ms soft confirmations and ETH as the gas token. Per-job settlement means a very high count of small payments, and that pattern needs cheap, fast finality. Being EVM-standard also means existing wallets and tooling work unchanged.
Providers post a $QGRID bond sized to their hardware tier before they receive jobs. Output is spot-checked by redundant execution on a sample of jobs. A mismatch, or sustained downtime against the advertised SLA, slashes a portion of the bond. The bond is what makes bad behaviour cost more than it earns.
No. Workloads can be paid in stablecoins. Paying in $QGRID gets a reduced protocol fee, and the treasury's buy pressure comes from converting its fee share on the market either way.
Not yet. $QGRID has no deployed contract, and no address on this site should be treated as one. The dashboard runs on preview data so the mechanics can be reviewed before anything is deployed. Testnet deployment is Phase 02.
5% of revenue market-buys $QGRID and sends it to an address with no known private key. It is removed from circulating supply permanently. The burn rate is a function of network usage, so it accelerates as the grid gets busier.
Walk the whole model end to end — rent a GPU, price an inference call, size a provider bond, and see how an epoch of revenue would split.