The Denominator (aka The Meter Was Always Running In Joules)

“Information is not a disembodied abstract entity; it is always tied to a physical representation.”

Rolf Landauer, The Physical Nature of Information, Physics Letters A 217 (1996), 188–193

First, i trust everyone is safe.

Second, this one starts with a pricing page, which is an unpromising place to begin an essay about physics. Stay with me. What looks like a billing decision turns out to be a physics argument wearing a costume.

The company is Flexcompute³. They sell simulation computational fluid dynamics, and finite-difference time-domain electromagnetics, two workloads that have been eating supercomputers alive for as long as there have been supercomputers to eat. And they do not charge you for the computer.

They charge you for the problem.

The Word Itself

i always start with the word, Dear Reader, because the word usually knows more than the pitch deck.

Credit, from the Latin credere. To believe. To entrust. A credit is a belief about value held between two parties, and it is worth exactly what the issuing party says it is worth, right up until the moment they say otherwise. Every loyalty point, every arcade token, every airline mile, every cloud dollar. A belief.

Joule, from James Prescott Joule, who spent years measuring the mechanical equivalent of heat by churning water with a paddle wheel and watching the temperature rise. A joule is not a belief. Nobody can reprice it. It is a kilogram-meter-squared per second-squared and it will be that in Charleston, in Reston, on the moon, and after every company in this essay is a footnote.

Denominator, from denominare. To name. The thing that does the naming.

Hold those three. The whole essay is in there.

What They Actually Did

Here is the legacy model, which is the model essentially every cloud has used since the day cloud became a word:

   

Innocent-looking. It is not innocent. Sit with it for a second and you will see the problem, and once you see it you cannot unsee it anywhere in this industry.

If i bill you by the hour, i get paid more when my software is worse.

That is not a cynical reading. That is the arithmetic. A badly optimized solver running on a stalled node behind a queue is, to the provider, indistinguishable from a good quarter. The incentive gradient points directly away from the thing the customer wants. Everyone in the chain knows this and everyone has agreed not to mention it, the way you do not mention that the bar is pouring doubles.

Flexcompute changed the denominator. Their currency, the FlexCredit, is computed like this:

   

Spatial resolution times temporal resolution. The Tidy3D documentation says it plainly: a FlexCredit reflects the size of a simulation, in both grid points and timesteps, and it explicitly does not reflect the compute time required to run it⁴. (i am scoping that to Tidy3D on purpose, because that is the FAQ i read. Confirm the Flow360 terms separately before quoting them⁵ a company can run different billing models on different solvers, and i am not going to assume one from the other.) When you upload a job the system prints the maximum cost before a single cycle burns. If the physics converge early and the solver shuts off, the bill is prorated down⁶.

Read what that does to the incentive.

Now if their solver is slow, they tie up their own silicon longer and earn exactly the same number of credits. The risk moved across the table. They are now structurally obligated to write the fastest code on earth, because every hour they shave is an hour of their own hardware they get back. Their own documentation offers a rough benchmark: one FlexCredit is somewhere around fifty hours of traditional CPU core time for FDTD⁷. Their job is to make that number keep falling, and the pricing model is what makes it their job.

Plenty of companies write mission statements about customer alignment. This is one of the few that put it in the arithmetic instead, where it cannot be walked back by a new VP.

#TCTRules: The denominator is the strategy. Everything above it is marketing.

And Now On With The Show

Because grid points times time steps is a good denominator. It is not the last one.

It is a model of the work. A very good model – it is the literal mathematical definition of the problem, which is why it feels so clean. But it is still a human-chosen proxy that a company issues and a company could, in principle, reprice. It is a credit. It is a belief.

Go one level down and you hit the thing nobody issues.

   

Normalized compute per unit of power. FLOPS per watt, tokens per joule, useful answers per kilowatt-hour. The Green500 has ranked supercomputers this way for years⁸, which tells you the people closest to the metal worked this out a long time ago while the people writing the invoices did not.

And here is why it is a different kind of number than everything above it.

Hours drift. A 2015 hour and a 2026 hour buy wildly different amounts of computation, which means every contract denominated in hours is silently repriced by Moore’s law and nobody renegotiates. Instance types drift the same label buys different silicon in different regions in different years. Seats drift. Credits drift, because the issuer can change the conversion.

A joule is defined by physics, not by a vendor. It is the one quantity in the entire stack anchored to the universe instead of to a price list.

Be careful with that sentence, though, because a joule drifts too just not where you expect. It drifts in two places, and neither of them is the definition.

It drifts in price. Electricity costs wildly different amounts in different places and at different hours several fold, routinely, between a Virginia afternoon and an Icelandic midnight.

It drifts in what it buys. The number of computations a joule pays for has roughly doubled every year and a half for most of the field’s history, slowing to about every two and a half years since 2000⁸. A 2015 joule and a 2026 joule buy wildly different amounts of computation, exactly as the hours do. That is the eight or nine orders of headroom from the next section, being spent in real time.

So the joule is not immune to drift. What it does is put the drift where you can see it. An hour folds efficiency, silicon, and margin into one opaque rate, and the vendor’s internal business stays internal. A joule splits the same drift into two public numbers: a price you can index and hedge, and an efficiency – useful work per joule – you can measure. The thing that does not drift is the problem itself: a converged simulation, a retained token, a validated answer. Price that against a reference joule count that is revised on a published schedule, and the drift stops being hidden and starts being shared. That is the whole proposal, and i will get to it.

The Floor

Now go all the way down, because this is where it stops being an economics essay and becomes a physics one.

There is a hard thermodynamic bottom to computation and we have known about it since 1961⁹. Landauer’s principle: erasing one bit of information dissipates at least of energy as heat. Run the numbers at room temperature, 300 kelvin:

   

Two point eight seven zeptojoules¹⁰. Which means one joule, spent perfectly, with no waste whatsoever, buys you about bit erasures. That is the floor. Not an engineering target – a floor, the way the speed of light is a floor.

The honest footnote, because the physics in this blog is not allowed to be knowingly false: the bound is on erasure, not on computation as such. Reversible computation can in principle dodge it¹¹, which is a genuinely open and genuinely interesting corner of the field. But every machine any of us has ever shipped erases constantly, and every one of them is running something like eight or nine orders of magnitude above that floor.

Eight or nine orders of magnitude. Sit with that. We are not near the wall. We are not even in the same county as the wall. Everything between here and there is headroom, and headroom is where value lives.

And Shannon got there before Landauer did, from the other direction. The Shannon limit says there is a minimum energy per bit for reliable communication: cannot go below , which is -1.59 dB¹². Information theory and thermodynamics, walking into the same bar from opposite doors, and both of them ordering in joules.

The price was always in energy. We have simply been billing in a proxy currency and calling the proxy the thing.

The Token Is Not A Layer

“The choice of a logarithmic base corresponds to the choice of a unit for measuring information.”

Claude E. Shannon, A Mathematical Theory of Communication, Bell System Technical Journal 27 (1948), 379–423

Dirt To First Token through the energy layer.

Owning a layer and choosing a denominator are two different moves. The layer is the thing you own, and other people stand on. The denominator is the unit you meter it in. You can own a layer and meter it stupidly. You can pick a brilliant denominator for a layer you don’t own; that is called being a reseller.

Which brings me to the token, and i want to say this plainly because a lot of money is currently confused about it:

A token is not a layer. A token is a unit of account.¹³

Nobody owns tokens. They are the metering unit for a layer that somebody else owns: silicon, memory bandwidth, and a power purchase agreement. Confusing the two is how a company ends up believing its moat is a billing unit.

And here is the part that should make every person reading this sit up, because the token denominator has the same bug the hour has, just rotated.

Per-token pricing is linear. The physics is not.

i wrote about this in SnakeByte[21]¹⁴, about the long-context arms race: standard self-attention has computational complexity that scales quadratically with the sequence length ¹⁵. So a hundred thousand token prompt is not a hundred times a one thousand token prompt at the attention step. It is far worse than that. The invoice says linear. The silicon says quadratic.

Any time the price curve and the cost curve have different exponents, somebody is eating the difference, and the pressure that creates does not point at making long context genuinely cheap. It points at quietly capping the window, degrading retrieval, truncating the middle, and hoping nobody runs the experiment. Same adversarial gradient as the hour. Different rotation.

It gets worse, and better, when you look at what is physically happening. Prefill processing the prompt is compute-bound. Decoding, generating the next token, is memory-bound. i surveyed this at length in the disaggregation piece¹⁶ and the whole reason the field is splitting those phases onto separate clusters is that they are two different machines pretending to be one.

Two different machines means two different energy profiles. Moving a byte out of high-bandwidth memory costs substantially more energy than doing arithmetic on it once it has arrived¹⁷.

Providers do not charge one flat rate per token. They already tier. Output tokens run roughly three to six times the price of input tokens the median across the market sits near four and cached input is routinely discounted to something like a tenth of a fresh input token. Some models have started charging a long-context surcharge above a couple of hundred thousand tokens¹⁸.

Look at what that tiering actually is. Input is prefill, which is compute-bound. Output is decode, which is memory-bound. Cached input is prefill you already paid for and do not have to redo. The pricing sheet has been quietly converging on the physics for two years and nobody has said so out loud. It is the same move Flexcompute made, arrived at by trial and error instead of by design.

Which makes the remaining gap the interesting part, and it is still a gap. Three buckets is not a measurement. Input, output and cached is a coarse quantization of a continuous cost surface, set by what the market will bear and revised when margins hurt – and inside every one of those buckets the exponent mismatch is still running, because attention is quadratic and the bucket is priced per token. The surcharge above two hundred thousand tokens is the tell. That is not a pricing strategy. That is a quadratic poking through a linear schedule hard enough that somebody had to patch it.

i already proposed a better denominator without quite noticing i had. In that same piece i suggested metered billing based on tokens stored and tokens retrieved – which separates the memory term from the compute term, and is therefore closer to the physics than a flat per-token rate. That is exactly the move Flexcompute made. Split the proxy into the parts that actually cost different amounts.

And one level below mine is the one i did not write, which is this whole essay:

   

i ended that post with the architectural arms race is becoming a memory computation problem, and then i signed off with Got More Ram? i meant it as a joke about capacity.

It is not a capacity question. Memory movement is where the energy goes. Got more ram is an energy question wearing a capacity costume, and i did not see it until i went looking for the denominator underneath my own denominator.

Atoms, Bits, Atoms

Here is why physics-based simulation is the right place to have found this argument, and not an accident that it showed up there first.

Simulation is a round trip. It starts in atoms and it ends in atoms, and everything in between is a detour through representation.

   

A wing exists. Air exists. Neither of them is doing math. The air is simply obeying Navier-Stokes because it has no choice, in continuous time, at no computational cost to itself, everywhere at once. We cannot watch that directly at the resolution we need, so we chop the wing into a mesh, chop time into steps, quantize every continuous quantity into a finite number of bits, and then ask a machine to imitate what the air was already doing for free.

Then we convert back. We cut metal. We etch a photonic circuit. Atoms again.

Every one of those arrows is a conversion, and every conversion is a tax paid in energy and fidelity. This is the same border i wrote about in the analog essay¹⁹, with the stakes raised: life is not band-limited, and neither is a wing in turbulent flow. We sample it anyway because countability is a magnificent trade. But we should at least know what we are being charged.

And look at what the arithmetic in the middle actually is. Strip away the frameworks and the schedulers and the driver stack and you reach the same irreducible operation in almost every workload that matters right now:

The Almighty Dot Product.

Multiply a row by a column and accumulate. That is a CFD (computational fluid dynamics) solver doing a sparse matrix-vector product inside a Krylov iteration. That is a finite element code applying a stiffness matrix. That is attention computing how much one token cares about another. That is a convolution. The GPU won the last decade not because it is a graphics device but because it is a dot product device, and the whole industry quietly reorganized itself around the one primitive the hardware does well.

For anybody who has not spent a career inside a solver: CFD is simulating how a fluid moves. Air over a wing. Water through a pump. Blood through an artery. FEA is finite element analysis, simulating how a solid deforms and where it fails. The load on a bracket, the stress in a bridge, a phone chassis meeting a sidewalk. Even acoustical rendering. All work the same way: chop the thing into millions of small pieces, write down how each piece affects the pieces touching it, and solve. That stiffness matrix K is exactly that bookkeeping for a structure – how every piece pushes back on every other piece.

For those that remember it, here is the math. One operation:

   

And here is that same operation wearing four different hats:

   

Four fields, four vocabularies, four sets of conferences that do not talk to each other. One sum of products.

And i want to make the strong version of that claim, because it is the point and not a footnote. These are not four analogous operations. They are the same operation. Each one is a bilinear form – a sum of products – and every one of them can be written as

   

for some matrix . The only thing that changes between the four is what looks like. Sparse for CFD and FEA, because a cell or an element only touches the ones next to it. Toeplitz for convolution, because the same kernel slides along the signal and every row is the row above it shifted by one. Dense for attention – and this is the genuinely new thing in the list – with the matrix produced by the data at runtime rather than fixed in advance by the geometry of a wing or a bracket.

What belongs to this family is the kernel and the final multiplication by . The softmax sitting between them is not a bilinear form and is not the same operation at all. Attention is a sandwich of two dot-product layers with a nonlinearity in the middle. The bread is the same. The filling is not.

Same function. Different structure. And here is why that matters for an essay about energy: the structure is where the joules hide. A sparse matrix, a sliding kernel, and a dense data-dependent matrix have wildly different memory access patterns, and memory movement is what costs. The arithmetic is identical across all four. The energy is not even close. Which is exactly the gap a denominator ought to be measuring and the hour never could.

Underneath all of it is the single instruction the silicon actually executes – multiply, add it to what you already had, keep going:

   

That is the whole machine. Everything else is scheduling.

Which means the leverage point is not the model and it is not the framework. Change what a dot product costs and you change everything stacked on top of it, all the way up to the invoice.

Now the part that made me want to write this section.

In a digital machine, a multiply-accumulate is hundreds to thousands of transistors switching, each one dragging charge across a capacitance and dumping it into the heat sink. In an analog crossbar, you apply voltages along the rows, store the weights as conductances at the crosspoints, and let Ohm’s law do the multiply and Kirchhoff’s current law do the sum. The answer arrives on the wire as a current. One step. No clock. No instruction fetch²⁰.

   

Look at that sum, then look back at the dot product. Same equation. Conductance standing in for one operand, voltage for the other, and Kirchhoff performing the accumulation for free, because current arriving at a node has nowhere else to go.

Read the symbols slowly, because each one is doing something a digital machine has to work for.

is conductance – the reciprocal of resistance, measured in siemens, which is a unit named after a man and not a committee. is the voltage you put on row . And Ohm’s law, written in the conductance form, says the current through that crosspoint is .

The multiplication happens because the device exists. Nobody issued an instruction. There is no opcode for it. Apply a voltage to a resistor and the multiplication has already occurred by the time you finish reading this sentence, because the electrons are not waiting for a clock edge.

Then the sum. Every crosspoint on column dumps its current onto the same wire, and charge is conserved, so the wire carries the total whether anybody wanted it to or not. Kirchhoff’s current law is the accumulator. It costs nothing because it is not a step. It is a consequence.

Now the part that matters for this essay. In a digital machine, the weight is a number. It lives in memory, and to use it you fetch it, move it across a bus into a compute unit, multiply, and move the result back and every one of those moves is where the joules actually go. In the crossbar, the weight is the device. Storage and arithmetic are the same physical object. There is no bus, because there is nothing to move.

That is not a faster von Neumann machine. That is a machine with the von Neumann bottleneck removed by construction. (there is another blog here on the aspects of Von Neumann moving ahead, but i digress)

And the cost changes shape though not the way the brochures say. A digital matrix-vector product on an matrix costs on the order of operations, executed one after another in time. The crossbar does every one of them at once and reads the answer in a single settling time. The clock says constant.

The physics does not. The array is still devices, every one of them dissipating, so the energy still scales as . The settling time grows with the resistance and capacitance of the wires, and the voltage drop along a long row caps a practical array at a few hundred lines, so a large matrix gets tiled across many arrays and the partial sums get added back up digitally. You did not escape the . You moved it from time into space and paid for it in joules.

Which is the most useful thing in this whole section, because it is the cleanest demonstration of the argument i am making. The clock says one step. The instruction count says nothing at all. The joules still say . Only one of those three gauges is telling you the truth about the work.

Analog is noisy. Device-to-device variability, drift over time, temperature dependence, and an effective precision that is realistically a handful of bits rather than thirty-two. Writing the conductances is slow and wears the devices out, which makes this a good inference machine and a poor training one.

And here is the part that should make you laugh, given where this section started: you still need converters at the edges. Digital in, analog across the array, digital out and in a great many designs the analog-to-digital converters on the output side dominate the energy and the silicon area²¹. The conversion tax does not vanish. It gets pushed to the boundary, where it sits waiting for you, exactly as it did in the wing and the mesh.

But notice what has happened to the denominator while we were looking at physics.

There is no instruction count in that equation. No clock. No opcode stream to add up, because nothing is executing in the sense the word usually means. You can still count the multiply-accumulates on paper – there are of them – but nothing on the machine counts them for you, and the meter that every invoice is built on has nothing to read. The hour means nothing. The instruction means nothing.

One quantity survives the trip: the energy it took to settle.

The machine is not simulating the dot product. The machine is the dot product.

And once you say that out loud, the next question asks itself: how far does that go?

A human brain runs on roughly twenty watts²². Two dim light bulbs. It is a chemical, analog, massively parallel machine that computes by being the physics – ions crossing membranes, gradients relaxing, concentrations doing the arithmetic directly. No mesh. No time steps. No clock. Neurons do fire in all-or-none spikes, so it is a hybrid machine rather than a purely analog one – but almost nothing in a brain converts the world into a number and back.

We are currently spending megawatts to approximate a fraction of what twenty watts does natively, and we are doing it by first converting the world into integers. That gap is not a scandal and it is not a mystery. It is a conversion tax, and it is the single largest line item in computing that nobody prices.

Neuromorphic silicon, in-memory compute, photonic matrix units, and the genuinely strange work in molecular and chemical computation are all, whatever their marketing says, one bet: that the way out is to stop converting. To get the atoms to do the arithmetic.

And the only unit that lets you compare any of them is the joule.

That is the argument underneath this entire essay. You cannot compare a GPU-hour to a neuron. You cannot compare a FlexCredit to a chemical reaction network. The unit does not survive the trip across substrates – it is defined in terms of the machine. But joules per converged solution, joules per retained token, joules per useful answer: those are quotable by silicon, by an analog crossbar, by a vat, and by a skull.

Energy is the only denominator that is substrate-independent. Which makes it the only one you can run a market in when the substrates stop being the same.

The Pendulum Knows The Way Home

i wrote an essay a while back about returning to the analog, and i made a claim in it i want to come back to. i said we will have analog computing devices again physics doing the mathematics directly, in proportion, instead of counting its way toward an answer.

i made it then as an aesthetic claim. The crossbar above is the argument i did not have at the time, and it is an energy argument.

Nobody is going back to analog because it is charming. It is coming back because when the binding constraint becomes joules per useful answer, a machine that computes by being the equation holds a thermodynamic advantage that no process node will close.

Analog degrades. Digital detonates. And on the right problem, analog is cheaper in the only unit that cannot be redefined by the company sending the invoice.

A Proposal: The Joule Standard

So let me invent the economic model rather, because if you do not set a standard, someone else will set it for you.

First, the metric. Call it the Landauer Ratio:

   

The problem is that a metric you cannot compute is a slogan.

No real workload tells you how many bits it erased. Nobody instruments that, the compiler does not know, and for anything above a toy circuit the number is not recoverable even in principle without a model of every intermediate the machine threw away. The pure form of that ratio is a thought experiment. It is good for establishing that a floor exists and useless for writing a contract.

The version you can actually bill against is per useful unit:

   

where the reference is a published best-known implementation of the same transformation at a stated level of the stack – not a thermodynamic ideal. That turns an absolute physics claim into a relative efficiency measure, which is weaker, less romantic, and the only one that can be audited. Say plainly which of the two you are quoting. Mixing them is how a number becomes marketing.

Landauer still sets the floor underneath both: about 2.87 zeptojoules per bit erased at room temperature. You have to say at which level of the stack you are measuring, because the number moves enormously depending on where you put the probe. A single CMOS gate switching is something like three to four orders of magnitude above . A whole system doing useful work picojoules per bit, counting data movement, the memory hierarchy, the interconnect, and the cooling, lands nearer eight or nine23. The gap between those two numbers is not measurement noise. It is the transport. Which is the thing this entire essay is about.

That ratio, how far above the floor you are, measured at a stated level, is the single most honest quality metric available for a computer, and almost nobody publishes it.

Now the business model, and the design constraint, is the thing that killed the hour: you cannot simply bill per joule. If you do, the provider earns more by burning more and we have rebuilt the exact adversarial gradient we just spent this essay diagnosing. Charging for energy consumed is the hour wearing a lab coat.

So invert it, the way Flexcompute inverted the clock:

   

where is useful units delivered, the reference joules per unit, what the provider actually spent per unit, and the contracted price per joule.

i am calling the second line the efficiency carry rather than the provider’s margin on purpose. They are not the same number, and the difference comes up in a moment.

Three moving parts, and one of them nearly sank the whole proposal, so let me take it head on.

cannot be the grid price. i wrote it that way first and it is wrong. Energy is a minority of what a fleet of accelerators actually costs – the silicon, the building, the cooling plant, the network and the people dwarf the electricity bill. Price joules at what the utility charges and the revenue never recovers the capital. The model collapses on contact with a balance sheet.

So is a contracted compute-joule price: the cost of one delivered joule of useful computation with the capital amortized inside it, indexed to a published grid reference so the energy component moves transparently instead of silently.

Which also means the efficiency carry is not profit. Once the capital lives inside , what one delivered joule actually costs the provider depends on how busy the hardware is – a fleet running at forty percent utilization carries more than twice the capital per joule of one running at ninety. Cutting joules turns into margin only two ways: more useful units out of the same assets, or an energy bill large enough that the saving shows up directly. A provider that gets efficient and leaves its silicon idle has improved its Landauer Ratio and lost money doing it. The carry is the incentive. Utilization is still the business.

A contracted price is a negotiated number. There is a credere living inside . i spent the first half of this piece separating beliefs from measurements, and here is a belief sitting in the middle of my own mechanism. The difference – and it is the whole difference – is that it sits in exactly one place, it is named, and it is indexed to something public. The hour hides a belief in every term and indexes none of them.

The useful unit is domain-defined and public: a converged simulation at a stated residual, a retained token, a resolved design candidate, a validated inference. It is the thing the customer actually came to buy.

The reference joules per unit is a published, periodically revised benchmark – the way the Green500 or SPEC work²⁴, and with all of the same politics, which i will come back to. It is the industry’s current honest estimate of what this transformation costs in energy.

The price per joule is the contracted number from above the one place a belief is allowed to live – with its energy component indexed to a grid, so the part of it that moves is set by someone other than the vendor.

As written, the provider keeps the entire carry until the reference is revised, and that is not how performance contracting works anywhere it has survived. Energy service companies split measured savings with the customer²⁵, because a contract where one party captures everything gets renegotiated in bad faith the moment it starts to bite. So put a share in it:

   

with the customer taking the rest. And here is the trade nobody gets around: you can have a bill that is predictable before launch, or you can have per-transaction savings sharing. Not both in the same term. The moment the customer’s share flows back per job, the invoice depends on and the up-front certainty is gone.

My own preference is per transaction – full predictability, provider keeps the carry – with the sharing happening intertemporally, through the ratchet. Revise down on a published schedule and the customer collects every efficiency gain on a known cadence instead of a noisy one. Buyers who would rather have the upside than the certainty take an below one and accept a variable bill. Write both contracts. Let the counterparty pick which uncertainty they would rather hold.

What that produces is the FlexCredit property one level down – a bill fixed before launch and tied to the customer’s own problem, and a provider whose every improvement to the solver, the memory hierarchy, the interconnect, the cooling or the substrate lands in its carry without a pricing committee. A performance contract, applied to computation itself.

And the reference ratchets. When the benchmark is revised down, yesterday’s carry becomes today’s table stakes – which is precisely what Moore’s law should have done to pricing for forty years and never did, because the unit of account was a machine-hour and machine-hours silently got cheaper while the invoice did not.

Why it matters for the chemistry. Under this model, a neuromorphic chip, a photonic unit, an analog crossbar, and a reaction network can all bid for the same job, because they quote in the same unit and get paid for the same thing. A substrate that is ten thousand times more efficient on a narrow class of problems does not need to win a general-purpose benchmark or displace an ecosystem. It just needs to show up with a better Landauer Ratio on one workload and collect the carry. That is how you get a market in exotic computation instead of a research program.

Where It Measured

Metering. Attributing energy to a single job across shared, virtualized, multi-tenant infrastructure at fine grain is genuinely hard and partly unsolved. Rack-level telemetry exists; honest per-job attribution including memory movement, network, and cooling overhead does not, at the fidelity a contract would need. This is the real engineering problem and it is where i would start if i were building the company.

Benchmark capture. Whoever writes the reference wins, and incumbents will try to write it. Any version of this governed by the largest providers converges on a baseline generous enough to guarantee their own margin.

Naming a risk is not a design, so here is the design. is not negotiated. It is set at a stated percentile of measured results on a published, versioned benchmark suite, administered by a body in which buyers hold at least as many seats as sellers, with the methodology public and every revision carrying an announced effective date so nobody can reprice retroactively. And there is a challenge procedure: any party – a competitor, a customer, an academic with a cluster – can submit a measured workload that beats or misses the published reference by more than a stated threshold and force a review inside a fixed window.

And the percentile cannot be drawn only from what sellers choose to report. Any target set from last period’s results teaches the people being measured to hide their best results – the ratchet effect, which economists documented in Soviet production quotas long before anyone built a data center²⁶. So the percentile is computed over every valid run: challengers’ and buyers’ measurements included, and every run on a contracted fleet reported, not a curated few. A provider that sandbags the benchmark to keep the reference fat should find a customer’s audit run sitting in the same distribution.

None of that is novel. It is how every serious measurement regime ends up working, from fuel economy to electrical safety, and every one of them was captured at least once on the way there. Assume this one will be too, and build the challenge path first rather than bolting it on after the first scandal.

The cheapest adequate answer. A provider paid on the efficiency gap has an incentive to find the least expensive result that passes. In simulation that means coarser meshes and looser convergence; in inference it means quiet quantization and shorter effective context. Any contract like this needs a correctness floor with teeth, independently verified, or the efficiency carry becomes a quality tax paid by the customer who cannot audit.

Not every domain has a useful unit. Simulation does. Retrieval does. Batch inference does. Open-ended conversation does not, at least not yet, and pretending otherwise is how you get a metric that measures the wrong thing extremely precisely.

What This Means For Everybody Building Right Now

The entire industry is currently in the largest capital buildout of my lifetime, and almost all of it is denominated in hours. GPU-hours, instance-hours, reserved capacity, committed spend.

Meanwhile go read what is actually holding projects up. It is not chips. It is interconnect queues. Substation capacity. Transformer lead times measured in years. Power purchase agreements. Siting next to a river or a reactor.

The constraint has been quietly turning into the watt, and the invoices have not caught up.

The numbers are public and they are not subtle. Berkeley Lab counted about 2,061 GW actively waiting in US interconnection queues at the end of 2025: approximately 1,312 GW of generation and 749 GW of storage, and in the regions that report it, the median wait from interconnection request to commercial operation ran over five years for projects that actually came online in 2025. The IEA puts data centers at roughly 415 TWh in 2024, about 1.5 percent of world electricity, headed for about 945 TWh by 2030, and estimates that around 20 percent of planned data center projects are at risk of delay unless grid constraints are addressed.²⁷ New transmission takes four to eight years in advanced economies. Nobody is waiting four to eight years for a GPU.

That gap – between the unit everyone is contracting in and the unit the physics is actually charging in is where the next decade of margin is going to be won and lost. It is the same shape as every call i have gotten right in thirty years, and now that i have split the sentence in two i can state it properly: own the layer everyone else treats as free, and meter it in the unit the physics is already using. In 2009, the layer meant underneath keywords. In 2026 it is the silicon and the power underneath the tokens – the tokens themselves being the meter, not the layer. And the unit the physics is already using, all the way at the bottom, holding up every other number in this essay, is a joule.

Flexcompute did not go all the way down. They went one level, from the clock to the problem, and that one level was enough to flip their incentive gradient from adversarial to aligned. That is the lesson, and it is available to anybody reading this:

Look at what you charge for. Then ask what behavior that denominator rewards when nobody is watching. That is what your company actually does for a living, regardless of what is on the wall.

The Stance

Find your denominator and say it out loud. Not your revenue – your unit. The thing you multiply by to get paid.

Then run the honesty test: if your product got twice as good tomorrow, would you make more money or less? If the answer is less, you do not have a pricing problem. You have an architecture that is quietly betting against your own engineers, and they can feel it even if they cannot name it.

And if you are building anything that will still be running in 2030, start carrying a second set of books in joules. Not because finance will ask. Because physics already is, and physics does not send invoices – it just stops giving you more.

Publish your Landauer Ratio before somebody else computes it for you. It is going to be an embarrassing number. It is an embarrassing number for everybody, which is exactly why the first few people to say it out loud will own the conversation.

The meter was always running in joules, Dear Reader. We have simply been reading the wrong gauge.

MUZAK TO BLOG BY: Kraftwerk, Radio-Activity. Men who understood that the signal and the power bill are the same conversation. On a pair of really good cans, at a volume that costs real watts. Check the track listing for the metaphor. The bass function for the rap beats we hear today.

Until then,

#iwishyouwater <- 2026 Small Mavericks in Half Moon Bay (i truly miss HMB)

#EverForward,

𝕋𝕖𝕕 ℂ. 𝕋𝕒𝕟𝕟𝕖𝕣 𝕁𝕣. (@tctjr) / X

Notes and References

Everything below was checked against the primary source. Where i could not verify something, the note says so instead of dressing it up. Prices and benchmark figures move; the dates are there so you know how stale a number is when you find it.

1. Epigraph. Rolf Landauer, “The physical nature of information,” Physics Letters A 217 (1996), 188-193. ↩
2. Epigraph. Claude E. Shannon, “A Mathematical Theory of Communication,” Bell System Technical Journal 27 (1948), 379-423 and 623-656. The line quoted is from the opening section, where Shannon is choosing his unit – which is the whole subject of this essay. ↩
3. Flexcompute. Company and product pages: flexcompute.com for Flow360, the CFD solver, and the Tidy3D FDTD electromagnetics solver. i have no relationship with the company and no position in it. i read their documentation because the pricing model is interesting. ↩
4. What a FlexCredit actually is. From Flexcompute’s own Tidy3D FAQ: “A FlexCredit reflects the size of a simulation, in both grid points and timesteps. It does NOT reflect the compute time required to run the simulation,” and “The cost of a simulation is primarily affected by the number of grid points and time steps.” Tidy3D learning-center FAQ, re-checked 30 October 2026. The billing page says the same thing in its own words: “FlexCredits are based on the size of the simulation (in spatial size and physical simulation duration),” with the printed maximum “determined by the cost associated with simulating the entire time stepping specified.” How is using Tidy3D billed? ↩
5. Flow360, scoped on purpose. The claim above is Tidy3D’s and i am not extending it to the CFD solver without a source. What is public: the Flow360 technical brief bills in “FlexUnits” – a different word from Tidy3D’s FlexCredit – and prices them at “$3.5/FlexUnit” against a NASA reference solver at “$0.04/CPU-hour,” so the unit is plainly not a CPU-hour. But the public materials i can find do not state what determines a FlexUnit. Flow360 Technical Brief (PDF). If you need the Flow360 terms, get them from the company in writing rather than from this essay. ↩
6. Priced before it runs, prorated if it stops early. “When a task is uploaded to our servers, we will print the maximum incurred cost in FlexCredit… This cost will be pro-rated if early shutoff is detected and the simulation is completed before the time stepping period.” How is using Tidy3D billed? ↩
7. One FlexCredit, roughly fifty CPU core-hours. Flexcompute’s own rough comparison for traditional FDTD – about two days of one core running continuously, with sixty FlexCredits put at roughly a four-core machine running flat out for a month. They qualify it “at the time of writing,” which is the right way to quote a moving number. How many CPU hours is one FlexCredit comparable to? ↩
8. Green500, and how fast a joule drifts. The Green500 ranks supercomputers by performance per watt, published twice a year alongside the TOP500. top500.org/lists/green500. For the long-run trend in computations per joule – the drift i say the joule is not immune to – see Jonathan Koomey, Stephen Berard, Marla Sanchez and Henry Wong, “Implications of Historical Trends in the Electrical Efficiency of Computing,” IEEE Annals of the History of Computing 33:3 (2011), 46-54, which found computations per kilowatt-hour doubling about every 1.57 years from the 1940s on; and Jonathan Koomey and Samuel Naffziger, “Moore’s Law Might Be Slowing Down, But Not Energy Efficiency,” IEEE Spectrum (2015), which puts the doubling time since 2000 nearer 2.6 years. ↩
9. Landauer’s principle. Rolf Landauer, “Irreversibility and Heat Generation in the Computing Process,” IBM Journal of Research and Development 5:3 (1961), 183-191. Full text (PDF), IEEE ↩
10. The number itself. at K works out to J. The erasures per joule is just the reciprocal of that – do it on a napkin, you do not need a source. For the experiment showing the bound is physically real and not an accounting identity: Antoine Bérut, Artak Arakelyan, Artyom Petrosyan, Sergio Ciliberto, Raoul Dillenschneider and Eric Lutz, “Experimental verification of Landauer’s principle linking information and thermodynamics,” Nature 483 (2012), 187-189. PubMed, PDF ↩
11. Reversible computation. Charles H. Bennett, “Logical Reversibility of Computation,” IBM Journal of Research and Development 17:6 (1973), 525-532 – the result that a computation carrying no erasure has no Landauer floor underneath it. Full text. This is the honest escape hatch under the whole section, and it is why the bound in note 9 is on erasure and not on computation. ↩
12. The Shannon limit on energy per bit. The dB floor for reliable communication falls out of the Shannon-Hartley capacity as bandwidth goes to infinity. Standard treatment: MIT OCW 6.451, Principles of Digital Communication II, ch. 4 (PDF), and the E_b/N_0 summary for the one-line version. ↩
13. The token as a unit of account. My own earlier piece on this: The Token Is The New Constraint (25 April 2026), where i argued that “every token is billable, forecastable, and optimizable” and that tokens “define bounded buffers of context.” That essay treats the token as a constraint. This one argues it is a meter, which is the correction. ↩
14. SnakeByte[21]. SnakeByte[21]: The Token Arms Race – Architectures Behind Long-Context Foundation Models (9 July 2025). The two lines i quote myself on are there verbatim: “Metered billing based on tokens stored and tokens retrieved,” and the sign-off, “the architectural arms race is becoming a memory computation problem,” followed by “Got More Ram?” i meant the last one as a joke. It was not a joke. ↩
15. Quadratic attention. The complexity claim in SnakeByte[21] – “a computational complexity that scales quadratically with the sequence length” – traces to the original formulation: Ashish Vaswani et al., “Attention Is All You Need,” NeurIPS 2017, arXiv:1706.03762. Every long-context architecture since has been an attempt to get out from under that exponent. ↩
16. Prefill and decode are two different machines. My survey: A Survey Of Architectures And Methodologies For Distributed LLM Disaggregation (August 2025). The primary literature: Yinmin Zhong et al., “DistServe: Disaggregating Prefill and Decoding for Goodput-optimized Large Language Model Serving,” OSDI 2024, arXiv:2401.09670 / USENIX; and Pratyush Patel et al., “Splitwise: Efficient Generative LLM Inference Using Phase Splitting,” arXiv:2311.18677. Prefill is parallel and compute-bound; decode is sequential and bound by memory bandwidth. That is the whole reason the field started pulling them onto separate clusters. ↩
17. Moving the operand costs more than the arithmetic. Mark Horowitz, “Computing’s Energy Problem (and what we can do about it),” ISSCC 2014 plenary, doi:10.1109/ISSCC.2014.6757323 – slides/paper (PDF). This is the paper everyone cites for the gap between the energy of an operation and the energy of fetching its operands, and it is the quantitative backbone of the argument that the denominator belongs on data movement rather than on FLOPs. ↩
18. Token price tiering. Checked against providers’ published pricing in October 2026. The pattern is consistent across the market: output priced several times above input, cached input discounted steeply, and at least one flagship model carrying a higher rate above roughly a 200,000-token prompt. These change often enough that you should read the current page rather than trust this one – Gemini API pricing, Claude pricing, and the equivalent page from whichever provider you are actually billed by. The argument in the essay does not depend on the exact multiples; it depends on the fact that the tiers exist and map onto prefill, decode and cache reuse. ↩
19. The analog essay. Return To The Analog (aka Life Is Not Band-Limited). That piece made the case on aesthetic and information-theoretic grounds. The crossbar section above is the energy argument i did not have at the time. ↩
20. Analog in-memory computing. The crossbar primitive – conductances as weights, Ohm’s law as the multiply, Kirchhoff’s current law as the accumulate – is the organizing idea behind a large body of work on in-memory and compute-in-memory accelerators. Reasonable entry points: “Analog or Digital In-memory Computing? Benchmarking through Quantitative Modeling,” arXiv:2405.14978, and “Memory Is All You Need: An Overview of Compute-in-Memory Architectures for Accelerating Large Language Model Inference,” arXiv:2406.08413. ↩
21. The converters eat the win. That data conversion at the array boundary dominates energy and area in many crossbar designs is a well-documented result, not a rhetorical flourish: see Anirban Nag et al., “Newton: Gravitating Towards the Physical Limits of Crossbar Acceleration,” arXiv:1803.06913, and the benchmarking paper in note 20. This is the same conversion tax as the mesh and the wing, relocated to the edge of the chip. ↩
22. Twenty watts. The brain runs about 20 percent of human resting metabolism on roughly 2 percent of body mass; against a resting budget near 100 W that lands at about 20 W. Source for the 20 percent figure: D. F. S. Rolfe and G. C. Brown, “Cellular energy utilization and molecular origin of standard metabolic rate in mammals,” Physiological Reviews 77:3 (1997), 731-758. For where the brain’s energy actually goes – mostly signaling – David Attwell and Simon B. Laughlin, “An energy budget for signaling in the grey matter of the brain,” Journal of Cerebral Blood Flow and Metabolism 21:10 (2001), 1133-1145 (PubMed 11598490); both are summarized with their antecedents at Harvard BioNumbers. Two dim light bulbs is a figure of speech, not a measurement – but it is the right order. ↩
23. Where the probe goes. The “three to four orders of magnitude” for a single CMOS gate versus “eight or nine” for a whole system doing useful work is a level-of-abstraction statement, not a single published number, and i want to be exact about why. A gate’s switching energy sits a few thousand times above . A system-level figure – picojoules per bit, counting the memory hierarchy, the interconnect, the cooling and the idle – lands several orders further out, which follows directly from the energy breakdowns in note 17. The spread between them is transport, and it is the only reason this essay has anything to propose. If you quote a Landauer Ratio, name your level or the number means nothing. ↩
24. Benchmark governance. Green500 and SPEC are the working models for a versioned, periodically revised public benchmark, including the politics. Both have been gamed. Both survived it by publishing methodology and run rules. That is the design to copy, challenge procedure and all. ↩
25. Performance contracting. The shared-savings and guaranteed-savings structures the Joule Standard is cribbing from have been in use for decades in energy services. See the IEA’s survey of energy performance contract models and, on the US federal side, Energy Savings Performance Contracts. The relevant lesson is not the arithmetic – it is that measurement and verification, not the contract language, is where these deals live or die. ↩
26. The ratchet effect. Martin L. Weitzman, “The ‘Ratchet Principle’ and Performance Incentives,” Bell Journal of Economics 11:1 (1980), 302-308 – the formal treatment of what happens when next period’s target is set from this period’s performance: the agent learns to under-report. Joseph Berliner’s fieldwork on Soviet factory managers documented the behavior decades earlier. Any benchmark that sets from self-reported results inherits it, which is why the percentile has to be drawn from runs the sellers do not get to curate. ↩
27. The grid is the actual constraint. Joseph Rand, Anna Cheyette, Chris Talley, Steven Zhang, Will Gorman, Ryan H. Wiser, Joachim Seel, Seongeun Jeong and Fredrich Kahrl, Queued Up: 2026 Edition – Characteristics of Power Plants Seeking Transmission Interconnection As of the End of 2025, Lawrence Berkeley National Laboratory, May 2026: about 2,061 GW actively seeking interconnection – 1,312 GW of generation and ~749 GW of storage – with a median of 61 months from interconnection request to commercial operation for projects built in 2025, among the projects with a valid in-service date (about 73 percent of them). i have quoted capacity rather than a project count because capacity is the figure i could confirm. Berkeley Lab. And International Energy Agency, Energy and AI (2025): data centers at “around 1.5% of the world’s electricity consumption in 2024, or 415 terawatt-hours,” projected to “more than double to around 945 TWh by 2030,” with roughly 20 percent of planned data center projects at risk of delay absent grid fixes, and new transmission taking four to eight years in advanced economies. IEA Executive Summary. ↩

A note on what is not cited. The economic model in A Proposal: The Joule Standard is mine and it is new, which means it has no reference because nobody has built it. The Landauer Ratio as defined here – measured joules per useful unit over a published best-known implementation at a stated level of the stack – is also mine, and it is deliberately weaker than the thermodynamic version so that it can actually be audited. Treat both as proposals, not findings. The physics in this essay is checkable and i have given you the receipts. The economics is an argument, and arguments are supposed to be attacked.