Docs

Coldplate rents GPUs by the second and runs AI models by the output on Robinhood Chain Testnet. Everything is paid in USDG from a balance in the Coldplate vault, which only its wallet can withdraw.

Start

  1. Connect a wallet and sign in. Signing in is a message, so it costs nothing.
  2. Open Balance and add funds: sign a USDG transfer to the vault, or pay with ETH.
  3. Sign a daily limit for the app. This is the most Coldplate may take from your balance in one UTC day.
  4. Make an output under Make, or start a GPU under GPUs.

Paying

Your vault balance has three parts:

Adding funds

With USDG, you sign an EIP-3009 ReceiveWithAuthorization to the vault and Coldplate submits it, so the deposit needs no ETH. With ETH, the ramp contract swaps it in the Uniswap v4 ETH/USDG pool and deposits the USDG in the same transaction. A plain approve and deposit also works.

The daily limit

The vault keeps one daily limit per spender. The Coldplate app is the spender whose address equals the vault address. You set or end a limit with a signed SpenderApproval, which Coldplate submits for you.

Prices

Every output has a fixed price per unit and every GPU an hourly rate, shown in the console and returned by GET /api/v1/models and GET /api/v1/gpus. A run that does not finish is not charged.

GPU rentals

Starting a GPU locks one hour of its rate. Each second it runs is counted. While it runs, the lock renews by one hour before it ends, as long as your balance and daily limit cover it. When the GPU stops, the vault settles the seconds used and returns the rest of the lock.

API

Base URL https://coldplate.pages.dev/api/v1. Amounts are integers of micro-USDG: 1000000 is 1 USDG.

Who is calling

The console uses a session cookie from signing in. Agents sign each request with their own key in the header x-coldplate-agent: address.timestamp.signature, where the signature is an EIP-191 signature of coldplate:METHOD:/path:timestamp and the timestamp is within two minutes.

GET    /models                    models and prices
GET    /gpus                      GPUs and hourly rates
GET    /account                   balance, limits, agents
POST   /outputs                   { model, prompt | text, image?, aspect? }
GET    /outputs                   your outputs
GET    /outputs/{id}              one output; the id is its key
GET    /outputs/{id}/file         the file
POST   /instances                 { gpu, vramGb?, preference?, hours?, image?, autoStopMinutes?, sshKey? }
GET    /instances                 your GPUs
GET    /instances/{id}            one GPU, with SSH and Jupyter
POST   /instances/{id}/stop       stop and settle
GET    /ssh-keys  POST /ssh-keys  DELETE /ssh-keys/{id}
GET    /agent                     an agent's budget and voucher base
GET    /receipts?owner=           vault events
GET    /receipts/{ref}            one grouped charge with proofs

POST /outputs answers 202 with the output while it is being made, or 200 once it is ready. Poll GET /outputs/{id} until status is ready.

Agents

An agent is a wallet address you link under Agents, with a daily limit you sign for it. It pays from your balance with a cumulative voucher: an EIP-712 AgentVoucher(owner, agent, cumulative, deadline) that states the total it has ever authorized for your wallet. Each new request needs a voucher whose total covers everything before it plus the new price. The vault settles parts of it in batches and never more than the signed total or the daily limit.

For a GPU, the agent signs a RentalOpen(owner, spender, id, lock, deadline) for the hours it asks for. POST /instances without a signature answers 402 with the exact message to sign.

x402

A request without a session or voucher gets 402 Payment Required with a PAYMENT-REQUIRED header (base64 JSON, x402 version 2) offering two schemes on eip155:46630:

Send the payment in the PAYMENT-SIGNATURE header; the answer carries PAYMENT-RESPONSE. For a GPU paid with exact, the hours are prepaid and the unused part goes to the payer's vault balance when it stops. A failed output paid with exact is refunded the same way.

import { wrapFetchWithPayment, x402Client } from "@x402/fetch";
import { ExactEvmScheme } from "@x402/evm/exact/client";

const client = new x402Client().register("eip155:46630", new ExactEvmScheme(account));
const pay = wrapFetchWithPayment(fetch, client);
const res = await pay("https://coldplate.pages.dev/api/v1/outputs", {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: JSON.stringify({ model: "flux-schnell", prompt: "a copper cold plate" }),
});

MCP server

The MCP server in packages/mcp gives a model these tools: list_models, list_gpus, budget, make_output, get_output, rent_gpu, list_instances and stop_instance. It signs with the agent key and pays with vouchers, or with x402 when COLDPLATE_PAY=x402.

{
  "mcpServers": {
    "coldplate": {
      "command": "node",
      "args": ["/path/to/coldplate/packages/mcp/src/index.ts"],
      "env": {
        "COLDPLATE_URL": "https://coldplate.pages.dev",
        "COLDPLATE_AGENT_KEY": "0x… the key made under Agents"
      }
    }
  }
}

The vault

The vault is at 0x0a69212eCc857004C9973d170616F13187B012C1 and holds USDG at 0x9fF8BbEF913dEaA7bC3700465093552925cbE326. Balances only become revenue in four ways, each bounded by something the wallet signed:

withdraw, withdrawAll and reclaimRental move money back to wallets and are open at all times. The USDG the vault holds is always at least the sum of every available and locked balance plus unswept revenue; the Foundry invariant tests check exactly that.

Receipts

Outputs are charged in groups, one per wallet and kind. A group's ref in the Charged event is a Merkle root: each leaf is keccak256(abi.encode(id, owner, model, units, price)) and pairs are sorted before hashing. Your receipts page lists each output with its proof against the root onchain. Rentals settle with a RentalSettled event holding the seconds used, the cost and what was returned.