A handful of companies sit between you and every AI model today. They filter what you can ask, they keep copies of what you say, and they set the price. At the same time, most of the world's GPU capacity sits idle: gaming rigs asleep overnight, workstations doing nothing on weekends, racks running half empty.

RobinCompute connects the two sides. People who want private, unfiltered inference on one end, GPU owners who want their hardware to earn on the other, and a chain in the middle instead of a company.

Workers host open-weight models like Llama, Qwen, DeepSeek, and Mistral, and collect USDG for every job they serve. Clients pay per job through an OpenAI-compatible API, so switching over usually means changing one line of code. Every job ends in a transaction on Robinhood Chain, an Ethereum L2, where anyone can pull it up and check it. Nothing here depends on believing us. The record is public, and the record wins.

A client submits a job and its cost locks in an on-chain escrow contract. The prompt is encrypted in the browser before it goes anywhere. An orchestrator mesh routes the ciphertext to the best available worker based on model, latency, stake, and reputation. The worker decrypts it in memory, runs inference, streams tokens back, and signs a proof of completion. Once the settlement contract verifies that proof, the escrow splits automatically: most of it to the worker's wallet, the rest to the protocol treasury. Nobody on the network reads your prompt, and nobody writes it down.

Workers can stake $RCOMPUTE for a larger cut of each job and priority in routing. Dishonest results get slashed. Reputation lives on-chain, and it cannot be bought, transferred, or reset.

If your code already talks to OpenAI, it already talks to RobinCompute:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.robincompute.org/v1",
    api_key="rcompute_live_...",
)

response = client.chat.completions.create(
    model="llama-3.3-70b",
    messages=[{"role": "user", "content": "Explain zero-knowledge proofs simply."}],
    stream=True,
)

for chunk in response:
    print(chunk.choices[0].delta.content or "", end="")

Or use the SDK, which hands you the on-chain receipt with every job:

import { RobinComputeClient } from "@robincompute/sdk"

const client = new RobinComputeClient({ wallet: userWallet })

const stream = await client.chat({
  model: "qwen3-8b",
  messages: [{ role: "user", content: "How do optimistic rollups work?" }],
  stream: true,
})

for await (const chunk of stream) {
  process.stdout.write(chunk.delta)
}

const receipt = await client.jobs.getReceipt(stream.jobId)
console.log(receipt.txHash) // verifiable on Blockscout

Your GPU has a day job now. Open the Earn dashboard in a WebGPU-capable browser, connect a wallet, pick a model that fits your VRAM, and jobs start routing within seconds. There is nothing to install and no account to create.

For higher rates, run the native robincompute-node daemon instead. It is a single binary for Linux, macOS, and Windows with CUDA, Metal, and ROCm support, serving models from 8B up to 70B and beyond. Register with a wallet, stake the minimum $RCOMPUTE, and the node announces itself to the network on its own.

RobinCompute is in open beta. Beta means early, not unfinished: the network is live, the contracts on Robinhood Chain were audited before mainnet, and the earnings a worker sees in their dashboard are transactions they can verify without asking us. The model catalog and worker pool are still growing, and we would rather say that plainly than dress it up. Expect changes to be additive rather than breaking.