Jul 2026
The bill is the work, not the wall clock
Every cloud on earth charges you for time. Time is the one thing about your job the provider fully controls and you can never verify.
Think about what a cloud bill actually measures. Seconds. You rented a machine, the meter ran, you paid for the wall-clock time it was on. But wall-clock time is a terrible unit for compute, because it answers the wrong question. A job that takes ten seconds on a tired old core takes two on a fast one — same work, five times the bill, or one-fifth, depending entirely on whose hardware happened to run it. You're not paying for the computation. You're paying for the provider's choice of machine and the provider's honesty about the stopwatch, neither of which you can see.
And here's the quiet scandal: you can't check a time bill. The provider says it took eight seconds. Did it? Was the machine throttled, shared, paused, padded? You have no way to re-derive the number. The unit of billing is a thing only one party can measure and only one party can fudge. We just decided that was fine because we had no alternative.
So we bill in a different unit entirely: instructions retired. When your program runs in our sandbox, the runtime counts the actual operations it executes — this many adds, this many loads, this many branches — and that count, "fuel," is the bill. Not seconds. Work. And the beautiful thing about counting work instead of time is that the count doesn't care whose machine it ran on. A million instructions is a million instructions on a laptop, a server, or a two-dollar chip. The number is a property of your program and your input, not of the hardware or the weather or how busy the provider was that afternoon.
Which means — and this is the part that turns a billing detail into the whole point — the bill is checkable. Because the sandbox is deterministic, the same code on the same input retires the exact same number of instructions every single time, on every honest machine. So when a provider hands you a receipt saying "this cost 1,048,576 fuel," that's not a claim you have to trust. It's a fact anyone can reproduce. Run it again, count again, get the same number. A provider who inflates the bill isn't committing a hard-to-detect fraud; they're signing a receipt that fails the instant one skeptic re-runs it, and their bond gets slashed for the lie. Overcharging stops being a risk you eat and becomes a move that loses money on average.
Time can't do any of this. You can't re-run last Tuesday's eight seconds. Time is gone the moment it passes; it leaves no artifact to check. Retired instructions leave a receipt you can recompute forever. One unit is a story the provider tells you. The other is a fact you can verify with the same program they ran.
There's an honest seam, of course — there always is. Fuel prices the compute, not the bytes: moving a big input across the network is its own metered cost, and a fast provider can still charge more per unit of fuel than a slow one, because speed is real and worth paying for. What fuel kills is the lie in the middle: the ability to bill you for a quantity you can't see and can't check. You still shop on price. You just can't be robbed on the meter.
Everyone else sells you time and asks you to trust the clock. We sell you work and hand you the receipt. Run it yourself.