For operators
Settlement follows work you can prove you did.
Run GPUs on Orogen and settlement is tied to completed inference jobs at oracle spot, denominated against the dollar. Pay tracks verified work, so a busy week produces more settlement activity and an idle one produces less. Honest operators are not diluted by emissions paid to passive holders, because new issuance is minted only against jobs that pass verification. Forge currently proves this path on testnet assets while production billing and token distribution remain release-gated.
What you run
Your inference server, plus three additions.
You run an open-source inference server you already know, such as vLLM, SGLang, or TRT-LLM, with three additions that turn raw throughput into work the network can pay for.
Hardware attestation
So the network can confirm the box is the hardware you registered.
Deterministic kernels
vLLM or SGLang determinism mode, so a validator re-running your job gets the same tokens you returned.
The receipt sidecar
Binds the model, the customer input, your output, and the attestation into a signed receipt that ships with every response.
Getting paid
How a payout reaches you.
A customer sends a request, your worker serves it, and the response goes back with its receipt. Validators independently re-run a sample of jobs on comparable hardware, and a matching replay confirms the work. On mainnet settlement the customer side burns OROG to pay for the job, the protocol mints against that verified work, and the operator-side flow can auto-swap a configured share to USDC. Forge exercises the mechanics with testnet assets; it is not a production payout surface.
Worked economics
One H100 SXM at the dc-standard tier.
These are design assumptions for capacity planning, in dollars per day. Real numbers move with your customer mix, regional cost basis, KV-cache hit rate, and utilization. The same per-GPU spread keeps Akash, Render, and Pearl operators in the market today.
| Line | Value | Source / assumption |
|---|---|---|
| Operator cost: 1× H100 SXM all-in (compute + power + bandwidth) | $48 / day | Mid-2026 mid-tier cloud rate; owned hardware 30–50% lower. |
| Throughput: Llama-3.1-70B FP8, batch-served, deterministic kernel | ~9,000 tok/s output | Typical SXM throughput with the deterministic kernel applied. |
| Customer price at dc-standard (0.6× base $0.40 / 1M out) | $0.24 / 1M out | Base posture; large customers negotiate sub-base via volume. |
| Billable volume at 50% utilization | ~389M output tok / day | Before routing and verification take their slices. |
| Break-even at this tier | ~200M billable tok / day | Reachable below half of the throughput above; capacity beyond is margin. |
Reference values are design assumptions for capacity planning and integration testing. They are not realized operator revenue, not a forecast, and not financial guidance.
Hardware tiers
Six hardware tiers, from datacenter to desk.
The protocol prices each tier as a multiple of the $0.40 base and asks for stake in proportion to the trust it extends. You self-declare a tier at registration. Validator probes can challenge a tier claim, and a sustained SLA breach (more than 5% of requests outside the latency bound over 24 hours, or more than 0.5% failed replay over 7 days) triggers an automatic downgrade. Higher tiers earn a larger price multiple because they carry hardware attestation and tighter SLAs, while lower tiers trade price for an easier path in.
| Tier | Hardware floor | Verification | Typical models | Min stake | Use case |
|---|---|---|---|---|---|
| dc-premium | 8× B200 / 8× H200 / NVL72 | L1+L2+L3+L4 (1–5% sampled) | DeepSeek-V3 671B, Llama-4-MoE, frontier MoE | 500 OROG | Enterprise frontier-tier, premium latency SLA |
| dc-standard | 8× H100 SXM | L1+L2+L3+L4 (1–5% sampled) | 30–70B dense, Mixtral, large MoE | 100 OROG | Mainstream production inference |
| cloud-rented | 1–2× H100 PCIe / H200 | L1+L2+L3+L4 (5–10% sampled) | 7–30B dense | 50 OROG | Spot capacity, secondary regions |
| prosumer | 1–2× RTX 5090 / PRO 6000 | L1 stake; L3 best-effort; L4 (10%+ sampled) | 7–14B quantized | 25 OROG | Lower-tier, hobbyist-friendly |
| edge | Mac Studio Ultra, dual 3090 | Stake-only | ≤ 32B single-user | 0 OROG (deposit only) | Private single-tenant inference |
| embed-only | CPU AVX-512, Apple M-series | Stake-only, optional L6 zkML | Embeddings, re-ranking, classification | 0 OROG (deposit only) | Cheap embedding + classification flows |
Stake floors are at-launch parameters; governance can adjust ±20% per epoch with timelock. Verification layers are described in How it works.
Attestation
Hardware roots, multi-vendor.
dc-premium / dc-standard
- H100 / H200 / B200 in Confidential Compute mode (NVTrust)
- Intel TDX or AMD SEV-SNP on the host
- Re-attestation every 7 days or on firmware update
- Multi-vendor TEE encouraged at the operator level (no single-vendor monoculture risk)
cloud-rented
- Same TEE substrate as dc-standard (1–2× H100 PCIe or H200)
- Provider-supplied attestation chain accepted if NVTrust + cloud-KDS endorsement present
- Higher validator sampling rate (5–10%) compensates for shared substrate
prosumer
- RTX 5090 / PRO 6000 (no CC mode available, falls back to stake-anchored verification)
- Deterministic kernel still required (vLLM determinism or SGLang determinism mode)
- Sampling rate at 10%+
edge / embed-only
- Mac Studio Ultra, dual 3090, Apple M-series, CPU AVX-512 (no TEE available)
- Stake-only verification posture; customer accepts weaker guarantees for cheaper pricing
- Embed-only tier may opt into L6 zkML for small workloads
Stake
Stake is the cost of cutting corners, scaled to the tier.
Stake is the first verification layer and the price of misbehaving. Floors run from 500 OROG at dc-premium down to a small deposit at the edge and embed-only tiers. Slashing is partial for a sampling mismatch and total for coldkey duplication or a fraudulent attestation, so the penalty matches the offense. Stake unlocks 14 days after you deregister, once no challenges remain open. Governance can adjust floors by up to 20 percent per epoch behind a timelock, so the numbers move slowly and in public.
Validators hold 10× the operator minimum for the tier they sample, which keeps the cost of a bad challenge higher than any payout it could earn. See Validators.
Settlement
Where each settled job goes.
Per-job settlement splits four ways, and every slice maps to a working role rather than a passive owner class.
| Recipient | Share | Rationale |
|---|---|---|
| Operator (provider) | 75% | The compute is the product. |
| Verification work (validators + opML watchers + zkML provers) | 15% | Paid in proportion to the verification actually performed and consensus alignment. |
| Protocol treasury | 5% | Audits, security response, customer integrations, at a bounded spend rate. |
| Governance stakers | 5% | Taken only while governance holds a real security function, and that slice folds back into verification otherwise. |
Nobody collects rent without doing the work.
Token
Why your pay does not get inflated away.
Customers pay in stablecoins, the gateway burns OROG to settle each job, and new issuance is minted only against verified work. Issuance tracks real inference revenue rather than a fixed inflation schedule, with a 5 percent per year supply ceiling, no foundation mint discretion, and no halving. You get paid for the work you did, not handed a slice of an emissions schedule that dilutes every week.
Bring-up
Get a node running.
# Build wallet-cli from source (release tarballs come with a signed release).
git clone https://github.com/orogen-network/wallet-cli.git
cd wallet-cli
cargo build --release
WALLET=./target/release/wallet-cli
# Point every command at the live Forge testnet RPC.
export OROGEN_RPC_URL=wss://forge-rpc.orogen.network
# 1. Create an account (sr25519 hotkey + EVM key from one mnemonic).
$WALLET new my-operator
$WALLET address my-operator
# 2. Fund it from the public faucet.
curl -X POST https://faucet.orogen.network/drip-public \
-H 'Content-Type: application/json' \
-d '{"recipient":"<the ss58 address from step 1>"}'
$WALLET balance my-operator
# 3. Register as an operator. --stake is in plancks; MinStake = 1_000_000_000_000 (1 OROG).
$WALLET register-operator my-operator \
--stake 1000000000000 \
--attestation-hash 0x0000000000000000000000000000000000000000000000000000000000000000 \
--rpc-url wss://forge-rpc.orogen.network
# 4. Submit an on-chain liveness heartbeat for the current epoch.
$WALLET heartbeat-test my-operator --submit --epoch <current-epoch>
The wallet CLI handles account creation, attestation binding, and
on-chain registration against the live Forge testnet RPC at
wss://forge-rpc.orogen.network.
You create an sr25519 hotkey, fund it from the public faucet, register
your tier with a stake in plancks, and submit a liveness heartbeat for
the current epoch. The worker daemon embeds your inference server with
the Orogen plugin loaded. Full commands and the worker images live in the
operator guide.