Running a node

Your spare RAM, rented by the hour.

A server you already pay for has memory sitting idle. One container turns it into something that earns. There is no wallet key on the machine and nothing runs as root.

What you need

A server: anything with RAM you can spare — a VPS is fine
Docker: that is the whole runtime
A public address: a hostname or IP renters can reach
Open ports: one per rental, from a range you choose
RAM: 100 per mebibyte you actually rent out
A wallet: stays on your own machine, never on the server

Stake is charged on memory that is rented, not on memory you advertise. Idle capacity costs you nothing, which is what lets a small machine join at all.

Post stake

Open Run a node in the console and post RAM. Only the part backing memory that is actually rented is held; the rest you can take back at any time.

Stake is fifty RAM for every mebibyte actually rented out, so four gibibytes fully rented needs 204,800. You can post more than you need — the page shows how much further your stake would stretch.

Withdrawing stake takes an hour from the request, and only the part not held against live rentals can be asked for at all. The delay is the point: stake that could leave the moment a node started failing would never be there when it mattered. You can cancel a request at any time during it.

Declare a node

Say how much memory the machine is willing to give up. Declaring costs one transaction and needs no stake behind it; a node with nothing staked is listed but cannot be taken.

Declare what the machine can really spare. Nothing on the network measures your free space today — so the figure is taken at your word, and the only thing holding it honest is that a renter who cannot get what they paid for will close and go elsewhere.

You can change the figure later, as long as the new one is not below what is currently rented.

Run one command

Press Launch line. You get a complete docker run, already filled in with the coordinator’s address and your node’s capacity. Replace the one placeholder — your server’s public address — and run it there.

docker run -d --name ram --restart unless-stopped \
  -p 7000-7999:7000-7999 \
  -v ram:/var/lib/ram \
  -e RAM_API=https://... \
  -e RAM_TOKEN=ram_... \
  -e RAM_PUBLIC_HOST=<this server's address> \
  -e RAM_CAPACITY_MB=4096 \
  ghcr.io/.../ram-agent:latest

RAM_API: where the coordinator lives
RAM_TOKEN: one-time, claims this node once, then is replaced
RAM_PUBLIC_HOST: what renters connect to
RAM_CAPACITY_MB: what you declared on chain
RAM_PORT_RANGE: optional, defaults to 7000-7999 — one port per rental
The volume: keeps the node identity across restarts — do not drop it

The launch line carries no wallet key. Everything that needed a signature happened in your browser; what reaches the server is a string good for claiming one node once. A stolen server costs you a node, not a wallet.

Watch it come up

Within fifteen seconds the node shows on air in the console and appears in the renters’ list. From then on it needs no attention: it reports what it is running, the coordinator answers with what should be running, and the agent makes the machine match.

There is no command queue and nothing to replay. If the container dies and comes back it simply reconciles again.

What the network checks, and what it does not

The coordinator keeps a roster: which nodes are answering, and where. A node that stops reporting drops out of the rentable list, so it receives no new orders — that much is real, and it is what the site reads when it decides whether to offer you.

What is not there: nothing probes a live rental to see that it is really serving, nothing fills your free space to prove it exists, and nothing takes stake from a node that fails. Those three checks are designed and not built. Until they are, an advertised gibibyte rests on the operator’s word and on the renter’s ability to walk away.

Billing follows the clock rather than a health record: time that passed on an open rental is time that is billed. A renter who is not getting what they paid for closes the rental, and closing early costs them nothing.

Getting paid

Sixty per cent of what a renter pays goes to you, forty to the network. Your share accumulates in the contract as the hours pass and you claim it whenever you like — there is no schedule and nothing expires. The network’s share is not accumulated at all: it is transferred to the treasury in the same transaction that bills the hour.

Moving or reinstalling

Keep the volume and the node survives a restart untouched. If you are moving to another machine, or you lost the line, press Issue a new one.

A new launch line kills the old one immediately. The agent still running on the previous machine loses access the moment the new one registers — which is exactly what you want when the old machine is gone, and worth remembering when it is not.

More than one node on a machine

Possible: one wallet can declare as many nodes as it likes, and each runs as its own container with its own volume and its own port range. Worth asking why, though — two nodes on one server split the same RAM, and the daily proof will hold real memory for both.