COMPUTE, PAID IN PAIRS

01 — THE PROBLEM

Inference demand is spiky and hardware is not. A GPU bought for a peak sits idle through the trough, and the cost of that idleness is carried entirely by whoever owns the card. Meanwhile the people who need a model answered occasionally cannot justify owning hardware at all, so they rent it from a handful of centralized providers at prices set by those providers.

Both sides are worse off than they need to be. The owner is holding a depreciating asset that earns nothing between jobs; the consumer is paying a margin to an intermediary whose only real contribution is matching. The matching is the part worth automating.

02 — WORKERS

A worker is a machine supplying compute. It is measured rather than declared: deploying one runs a real WebGPU kernel and times it, so a class is a statement about what the hardware actually did, not what its operator claims. Browsers deliberately mask the GPU model to limit fingerprinting, which makes measurement the only honest basis for a class.

The rate is flat per class, not scaled by how much an operator already runs. Capacity is a property of a machine: two identical cards genuinely do the same work, and an operator cannot subdivide one GPU into several to game a curve. Running more machines means supplying more compute, which is the behaviour the network wants.

03 — FIRST ACCRUAL: $RAMP AND THE CLAIM BAND

Rewards accrue continuously and are claimed on demand. Rates are set so that a claim lands between 1,000 and 10,000 $RAMP — large enough to read as a payout, small enough that the number still means something.

That band is a cadence, not a promise about any single moment. The band spans ten times; class rates span ten to one and fleet sizes another twelve, so a hundred and twenty times of range has to land inside ten. No single schedule puts every fleet in band at the same interval, and forcing one would flatten the class spread until a GPU barely out-earned a CPU. Instead: every realistic fleet has some claim interval that lands in band, and the common case — one good GPU up to a dozen mixed machines — is in band claiming daily.

04 — SECOND ACCRUAL: THE DIVIDEND PAIR

An operator picks a second token at deploy time and earns it alongside $RAMP, at a weight set per token. This exists so that supplying compute is not a single-asset bet: an operator who wants stable revenue takes USDG, one who wants exposure to the hardware cycle takes NVDA.

One basis point is one ten-thousandth (10,000 bps = 1×). The dividend token is fixed for the life of a worker, so the choice is a commitment rather than a lever to flip with the market.

A weight is a share, not a price: it fixes how fast the dividend accrues relative to $RAMP, and nothing in it depends on what either token is worth. It also does not say where the dividend tokens come from. They are not minted and they are not emission — they are funded by trading in the $RAMP pool, which is the subject of section 06. First, the chain that makes these particular tokens possible.

05 — ROBINHOOD CHAIN

RAMP runs on one chain. Robinhood Chain is an EVM chain — an Arbitrum Orbit L2 with gas paid in ETH — so the contracts are ordinary EVM contracts, the wallets are the wallets people already use, and an address is the same checksummed 20-byte string it is everywhere else on the EVM.

CHAIN

ROBINHOOD CHAIN

CHAIN ID

4663

GAS

$ETH

STABLE

$USDG

EXPLORER

robinhoodchain.blockscout.com

The reason for this chain rather than another is the dividend. A dividend paid in NVDA is only worth offering if it is a real asset the operator can hold, sell or move — not a synthetic that tracks a price reported from somewhere else. Robinhood issues tokenised stocks on this chain directly, and the chain’s stable is USDG, Paxos’ Global Dollar. The pairs in section 04 are therefore assets native to the chain the worker is paid on: paying a dividend is a token transfer, not a bridge and not a promise to settle elsewhere.

One chain also keeps the rest of the design short. The pool that generates the fee, the markets the fee is converted through, the tokens it is paid out in and the shares it is credited to all settle in the same place, under the same finality.

A stock token is exactly the kind of asset that gets impersonated, and lookalikes already trade on this chain under the same tickers. Every contract in the table in section 04 is the one that names itself a Robinhood token on-chain and holds the dominant liquidity for its symbol — check any you use character for character against it, the same rule section 08 gives for $RAMP itself.

06 — HOOKS: VOLUME FUNDS THE DIVIDEND

The $RAMP pool on Robinhood Chain is a Uniswap v4 pool. Version 4 lets a pool attach a hook: a contract the pool calls at fixed points in every swap, which can act on the swap it is handed. RAMP’s hook does one thing with that. It takes a small fee on each swap through the pool and sends it to the dividend pool that the accruals in section 04 are paid from.

The fee rate is a protocol parameter, readable from the hook contract. It is charged on the swap, in the tokens the swap moves, so it is paid by the people trading $RAMP and by no one else. A holder who never trades pays nothing; neither does using inference, which is gated by a balance and never spends one.

The fee arrives in whatever the swap was denominated in, and dividends are owed in $USDG, $NVDA, $AAPL, $TSLA and $ETH. Getting from one to the other is a swap through the chain’s own markets, at whatever rate those markets give at the time — the rate anyone else would get. That is the only place a price enters the loop, and it enters as a trade, not as a reading.

So the loop has no oracle in it. Trading volume pays the fee; the fee fills the pool; the pool pays operators by weights that are shares, not prices. Nothing in the path asks what anything is worth, and nothing in it has to be trusted to report a number honestly.

A worker’s accrual and the pool’s balance are kept separate on purpose: an operator’s rate does not rise and fall with a day’s volume. How the two are reconciled when fees run ahead of accruals or behind them is defined in the contracts, where anyone can read it.

WHAT THE HOOK DOES NOT DO

• It does not price anything. There is no oracle and no price feed. The hook never reads a value; it takes a fraction of an amount.
• It does not touch emission. $RAMP enters circulation only as uptime is served (section 03). The hook neither mints nor burns $RAMP and has no say over the rate.
• It does not decide who is paid. Who earns a dividend, in which token and at what weight, is settled by the worker’s class and its pair. The hook only fills the pool.

07 — COMPUTE SHARES

A worker is a machine; an operator is whoever runs it. Compute shares let those be different people. A share is an NFT that represents a fraction of an operator’s fleet — its measured compute capacity, and everything that capacity earns. How many shares a fleet is divided into is fixed when they are issued.

Crediting is pro rata. Every hour a fleet serves accrues $RAMP at its class rates (section 02) and a dividend at each worker’s pair weight (section 04), exactly as it would with no shares at all. That total is then split across the fleet’s shares in proportion to how many each holder owns: a holder of a tenth of the shares is credited a tenth of the $RAMP and a tenth of each dividend token. Nothing about what the fleet earns changes — only who it is credited to.

Because workers are measured rather than declared, a share is a claim on compute that was actually demonstrated. The class behind it is what the hardware did in a timed kernel, not what its operator said about it, which is what makes a fraction of it something a stranger can evaluate. A share also inherits its fleet’s dividend pairs: they are fixed for the life of each worker, so buying a share is buying those pairs.

Claiming works as it does for a worker. Accrual runs continuously, and a claim settles the $RAMP and the dividend together. With shares, each holder claims their own portion, and one holder claiming moves no one else’s balance.

A share is transferable, and the income stream moves with it. Whoever holds the NFT is credited from the moment they hold it, and the previous holder stops being credited at the same moment. That makes a fleet’s future earnings something that can change hands without moving any hardware: an operator can sell a portion of a fleet’s income, and a holder can own compute income without running a machine.

Whether credit that has accrued but not been claimed at the moment of transfer travels with the NFT or settles to the seller is defined in the share contract. A holder who wants certainty claims first. Holding a share is not holding $RAMP: inference is unlocked by a $RAMP balance (section 08), not by a share.

08 — TOKENOMICS

TICKER

$RAMP

CHAIN

ROBINHOOD CHAIN

CONTRACT

—

Verify the contract against this page and the explorer before sending anything anywhere. A near-identical address is a different contract — the only safe check is a character-for-character one against a source you trust. The mixed upper and lower case is not decoration: it is an EIP-55 checksum, and it is what a wallet uses to catch a mistyped address.

The token does two jobs and no others. It is what a worker earns, and it is what a holder presents to use inference for free. Emission is therefore tied to work actually performed: tokens enter circulation only as uptime is served, so supply growth tracks the compute the network delivered rather than a schedule set in advance. The dividend does not change that — it is paid in other tokens, from fees, and never from new $RAMP.

Holding, not spending, is what unlocks inference. A holder’s balance is checked, never transferred — using the network costs nothing and burns nothing. That makes the token a key rather than a fee, and it means demand for inference becomes demand to hold, which is the loop that pays the operators supplying the capacity.

09 — WHY IT OUTLASTS US

Nothing in the loop above requires RAMP the company. Operators are paid by a rule anyone can read, from a pool filled by a hook anyone can read; consumers are admitted by a balance anyone can check; the matching is mechanical. A market with those properties does not need a custodian, and the infrastructure — the classification of hardware, the emission schedule, the holding-based gate, the shares that carry a fleet’s income — is meant to be built on rather than asked permission of.

That is the ambition: not a compute provider, but the settlement layer other compute products can assume. The measure of success is that someone builds something on this that we did not plan for.