How RAM Cloud works

RAM Cloud is a decentralized memory & compute network. Instead of renting capacity from one cloud provider, anyone can list spare capacity on their machine as a node, and anyone can rent it on demand. Workloads run on the network; payment settles on-chain.

Three roles make it work:

• Renters rent a node by the GB-hour, get a private endpoint + API key, and run workloads against it.
• Providers share idle capacity — straight from the browser, no install — and earn USDC for every task their machine handles.
• The network routes work to live nodes, audits them for honesty, and settles payments on Base.

For renters

1. Browse the marketplace, filter nodes by spec/region/price, and rent one. Pay in ETH or USDC on Base.
2. You instantly get a Redis-compatible endpoint + API key.
3. Open the RAM Console and use it: SET/GET for live key-value memory, or RUN <task> to offload a compute task to the node.

For providers

1. Open the Earn page and click Start Worker — it spins up a node in your browser tab using your GPU.
2. When a renter runs a task, your machine does the work and streams the result back.
3. You earn per task. Connect a wallet, pass a verification check, and withdraw real USDC on demand.

RAM Cloud has three parts: the client, a central orchestrator, and distributed nodes.

   Renter (browser)                 Provider (browser)
   ┌───────────────┐                ┌──────────────────┐
   │ Marketplace   │                │ Browser Node     │
   │ RAM Console   │                │ (WebGPU compute) │
   └──────┬────────┘                └─────────┬────────┘
          │  run task                heartbeat │  poll / result
          ▼                                    ▼
        ┌────────────────────────────────────────┐
        │           Orchestrator                  │
        │  • live-node registry (heartbeats)      │
        │  • routes each task to an idle node     │
        │  • audits nodes (proof of work)         │
        │  • managed fallback if none online      │
        └───────────────────┬─────────────────────┘
                            │ settle
                            ▼
                    Base  ·  ETH / USDC

Job lifecycle

1. A renter submits a task to the orchestrator.
2. The orchestrator finds an idle node and assigns it.
3. The node executes and returns the result, which is relayed back to the renter.
4. The node goes idle; its earnings are credited.

Browser nodes run on WebGPU — no install, no signup. They register with the orchestrator via heartbeat and pull work as it arrives. The orchestrator never persists task content; it routes and discards.

Nodes are tiered by memory class and speed. Pricing is per GB-hour and set by each provider:

RAM Console commands

Each rental ships a Redis-compatible console:

SET user:1 alice        # store a value in live memory
GET user:1              # read it back
INCR counter            # atomic increment
TTL session:1           # seconds until expiry
RUN summarize this log  # offload a compute task to the node
KEYS · DBSIZE · INFO    # inspect the namespace

Want to test a node first? The Try page gives every visitor $1 of credit on a shared node — no wallet needed.

Anyone can become a provider in one click — no install, no signup.

• Browser node: open Earn → Start Worker. A compute node loads onto your GPU in the tab (~0.9 GB, cached after first load).
• Requirements: a WebGPU browser (Chrome/Edge 113+) and ~6 GB of free VRAM.
• Earnings: you keep the majority of each task's value, paid in USDC. Earnings accrue live as you work.
• It runs while the tab is open. Close it and your node goes offline — no background process.

Because nodes report their own results, the network has to make sure they actually did the work before paying them. RAM Cloud does this with randomized verification challenges, mixed invisibly into the job stream.

• Hidden audits. The orchestrator occasionally sends a task it already knows the answer to. A node can't tell an audit from a real job.
• New nodes are vetted first. You can't earn-and-run until you've passed at least one check.
• Timing floor. Results returned faster than real compute is possible are rejected.
• Slashing. Fail repeatedly and your node is flagged, its accrued earnings are zeroed, and withdrawals are blocked.

The result: you genuinely have to do the work to get paid. (Cryptographic proof-of-execution is on the roadmap.)

Everything settles on Base (Ethereum L2) for fast, cheap transactions. Connect MetaMask and you're in.

• Renting: pay per GB-hour in ETH or USDC. Funds move wallet-to-wallet.
• Earning: connect a wallet, sign once (free, no gas) to register your payout address, then Withdraw real USDC on demand.

Payout safety limits

Every payout is an on-chain transaction. Workers see their full payout history — with a Verify on Basescan link for each — on the dashboard, so earnings are independently verifiable by anyone.

$RAM is the network's community token, launched on Bankr. It's designed to capture the value the network creates as it grows.

Planned value accrual (roadmap)

• A share of network fees flows to a treasury in USDC.
• Part of the treasury is used to buy back and burn $RAM — shrinking supply as usage grows.
• The rest is distributed to stakers; providers who stake earn a higher share of each job.