RAM
The ONCHAIN market for RAM
Spare memory on somebody’s server, rented by the hour. Around 30% under the cheapest managed cache — and your app keeps the Redis client it already has.
Eight gibibytes, a month.
$53.54 instead of $76.51.
A managed cache is a slice of RAM in a machine somebody already owns, with a vendor’s margin on top. The index below is read from those vendors’ own machine-readable price feeds, every day, and published on chain.
The anchor is the cheapest of the three, less the network’s discount — not the median. Thirty per cent off the middle of a spread that wide comes out dearer than simply buying the cheapest, which would price the network above the thing it exists to undercut.
The median keeps the job it is good for. A scraper that breaks usually breaks low, and a low reading would become the price of the whole network — so a source far below the middle is treated as broken rather than as a bargain, and nothing is published at all.
Two sides, and nothing between them.
Memory goes straight from one server to the other. The protocol holds the money and counts the hours; it never sits in the path of the data, and it cannot read it.
I need memory
- 01Deposit
USDG into the contract. It stays yours — withdrawable any time, minus a day of whatever you have running.
- 02Pick a size and a node
One transaction. The network puts you on a node with room and holds the price you opened at.
- 03Paste the address
A hostname and a password. Your Redis client already speaks the protocol, so nothing in your code changes.
I have memory
- 01Sign in the browser
Register the node with your own wallet. You get one line to paste — and no key ever goes on the server.
- 02Run one command
One container. No Docker socket, no root: the agent starts memory engines as its own child processes.
- 03Earn 90% of every hour
Claim whenever. Downtime is billed to nobody, so an hour your node was out costs the renter nothing.
Billed for the size, not the fill.
Which turns the meter into a clock. Nothing for a provider to inflate, nothing for a renter to dispute, and no traffic that has to pass through us to be counted — which is why you connect straight to the node and we cannot see your data.
Same size, same hours, the same bill to the last unit. Which is why there is nothing to measure, nothing to argue about, and no reason for your traffic to pass through us at all.
A clock, not a measurement. The same way a cloud cache has always been priced.
Fill it or leave it empty — the bill is identical, and there is nothing to argue about.
Nothing to count means nothing to route through us. Your traffic never touches the protocol.
Stake follows what is rented, not what is advertised.
Empty memory costs a provider nothing, so advertised capacity guarantees nothing and needs no stake. Only what somebody is actually paying for has to be backed — which is also why demand for the token rises with real usage instead of with promises.
Does the instance answer inside the timeout, is its memory ceiling what the rental says, and is the canary record still intact. The canary is pinned against eviction — an unpinned one would vanish exactly when a renter started using their space properly, and a busy node would read as a broken one.
The part nobody rents has nobody using it, so a four-gibibyte machine could advertise fourteen terabytes and answer every question correctly. The engine is told to allocate it itself — one short command over the wire, a real allocation on the node — and a machine that does not have the memory fails to hold it.
A run of failed checks takes a node out of service. Losing live data takes the whole stake. Half of what is taken goes to the renter who was let down; the rest is burned or kept by the treasury, and the split is checked on chain at the moment it is paid.
Memory bought today, at today’s price.
Pay now for gibibyte-hours you take any day in the next ninety. Memory gets dearer — you still take yours. The same bargain a prepaid cloud reservation makes, and the first time anybody has offered it on memory as a commodity.
The lock holds that far above the day the batch opened. Past it the holder pays the difference — which is what turns an open promise into a number.
Of what a batch sold for, fixed on the day it opened. The proceeds are held back in full, so the only exposure is the difference between then and now.
Behind it sits the reserve: every sale’s proceeds, held back in full rather than booked as income, plus whatever has been put in on top. What the programme could still owe and what stands behind it are both published on every page — because somebody handing over money for a promise should be able to see whether the last promise can be kept.
Three jobs, and no governance.
Stake behind the memory, a cut of every bill to the treasury, and a reserve that stands behind what the forwards sold.
A provider locks it against the capacity actually rented from them. No stake, no orders.
What a forward sold for is held back until the hours are delivered, and what an expired batch leaves behind stays to cover the next one.
The network keeps a share of every bill, transferred to the treasury in the same transaction that bills it.
A commodity nobody had priced.
Storage has a market. Compute has a market. Memory never did — and it is the one your application waits on.