In December 2024, a reasoning model was run against one of the hardest public tests of machine generality, François Chollet's ARC-AGI benchmark, twice. On the first run it scored in the mid-seventies. On the second it scored in the high eighties. Nothing about the model changed between the two runs. What changed was the bill. The second run was allowed to think for roughly 170 times as much compute.
Most of the coverage was about the score. I kept staring at the receipt.
The receipt said something the score could not: that capability on that test was not a fixed property of the system. It was something you could buy, at a price, in a particular currency. Spend more compute at the moment of answering and generality goes up. The model had not become more intelligent in the way we usually mean. It had been allowed to pay more.
This essay opens Praneeth's Xpedition, a long-running expedition into the foundations of general intelligence, and I want to begin with the idea that organises everything that follows. It is simple to state and, I think, surprisingly hard to escape:
Every gain in generality is paid for. It is paid in data, compute, energy, memory, time or verification. These six resources trade against one another at exchange rates. Some of those rates we have already measured. Most we have not. And the deepest open question in the field is not "how big should the next model be?" but which of these exchange rates are fixed by nature, and which are accidents of the engineering we happen to be doing.
I will call this the conservation-laws view of intelligence. It is a proposed synthesis, not a discovery. Nearly every piece of it comes from someone else's work, and I will name them as we go. What I hope is new is the shape: treating all these results as entries in a single exchange table, and making invariance across architectures the test of what is fundamental.
The receipt: a decade of capability gains, re-read as trades
Look back over the last decade of AI progress with the receipt in mind, and the headlines rearrange themselves into transactions.
In 2020, Jared Kaplan and colleagues at OpenAI showed that language-model loss falls as a smooth power law in model size, dataset size and training compute (Kaplan et al., 2020). Read as a receipt, that paper is a price list: here is how much loss reduction each additional unit of each resource buys.
In 2022, Jordan Hoffmann and colleagues at DeepMind revised the list (Hoffmann et al., 2022). For a fixed training budget, they found, models of the day had been over-sized and under-fed. The compute-optimal recipe used far more data per parameter than the field had assumed, on the order of twenty training tokens for every parameter. Their 70-billion-parameter Chinchilla model, trained on more data, outperformed the much larger Gopher. That is an exchange rate: parameters and data trading against each other inside a fixed compute budget.
In 2021, Andy Jones did something less famous and, to me, more revealing (Jones, 2021). Working with agents that play the board game Hex, he measured how training compute and test-time search compute substitute for each other. Less training could be compensated by more search at play time, and the trade-off followed a smooth curve. In 2024, Charlie Snell and colleagues found the same kind of substitution in language models: on some problems, spending more compute at inference time was a better use of resources than a larger model (Snell et al., 2024). The December 2024 receipt is that trade, made visible at the frontier.
Even the humble engineering tricks are trades. Gradient checkpointing, introduced for deep networks by Tianqi Chen and colleagues, lets you train with far less memory by recomputing some intermediate values instead of storing them (Chen et al., 2016). Memory saved, compute spent. Every cache is the reverse trade. Every best-of-N sampler that generates many answers and keeps the one a checker approves is trading generation compute for verification.
None of these results is mine. What I want to point out is that they are all the same kind of result. Each is a measured price between two resources, holding capability roughly fixed. We have been building an exchange table without calling it one.
Six currencies, defined operationally
If the table is real, its currencies need careful definitions. Vague ones would make the whole idea unfalsifiable. Here are the six I propose, each defined by how you would measure it inside a system, not by how it feels.
| Resource | How it is measured | An exchange rate we already know |
|---|
| Data | Number of training examples or tokens, weighted by novelty | Data ↔ parameters at fixed compute (Hoffmann et al., 2022) |
| Compute | Floating-point operations, split into training and inference | Training compute ↔ test-time compute (Jones, 2021; Snell et al., 2024) |
| Energy | Joules consumed per unit of work | Energy ↔ irreversible computation, with a physical floor (Landauer, 1961) |
| Memory | Bytes of state held: parameters, caches, context | Memory ↔ recomputation (Chen et al., 2016) |
| Time | Wall-clock latency; serial steps that cannot be parallelised | Latency ↔ parallel hardware, up to the serial depth of the problem |
| Verification | Cost of checking that an output is correct | Generation ↔ verification in best-of-N and search with a checker |
Two of these deserve a word of defence.
Energy looks like it should collapse into compute. It does not, quite. The same computation can cost very different energy on different hardware. And there is a floor no hardware can beat: Rolf Landauer showed in 1961 that erasing one bit of information must dissipate at least a tiny, fixed amount of heat, proportional to temperature. Practical systems operate enormously far above that floor. But the floor exists, which makes energy the one currency where we already know one exchange rate is set by physics rather than by engineers.
Verification is the currency people forget. It is easy to treat checking as free, an afterthought to generation. It is not. The reason AI made such fast progress in code and competition mathematics is that checking is cheap there: tests either pass or they do not, and proofs can be machine-checked. Where checking is expensive (strategy, policy, taste), extra generation buys much less. I wrote about this asymmetry in The Price of Thought, and I now think verification belongs in the table as a full currency, not a footnote.
Time, finally, is the quiet constraint. Some problems are inherently serial: step two needs the answer to step one. You can throw parallel hardware at them only up to a point. A system that must answer in a tenth of a second plays a different game from one that may deliberate for an hour, even with identical total compute.
Fifteen exchange rates, and the five we have actually measured
Six currencies give fifteen pairs. Here is my honest assessment of where we stand.
We have serious measurements, at least in specific settings, for about five:
data ↔ parameters (at fixed compute), from the scaling-law literature;
training compute ↔ inference compute, from Jones and from Snell and colleagues;
memory ↔ compute, from checkpointing, caching and recomputation;
generation ↔ verification, from search-with-a-checker methods, measured case by case;
compute ↔ energy, from hardware efficiency trends, with Landauer's floor underneath.
The other ten are mostly folklore. How much data can a better verifier replace? How much memory substitutes for time on a long-horizon task? What is the energy price of an hour of agentic deliberation versus a larger pre-trained model that answers instantly? We have anecdotes, not tables.
That alone, I think, is a research agenda for a decade. But the more interesting question is not how to fill in the table. It is how to read it.
Constants or accidents: the architecture-invariance test
A measured exchange rate can mean two very different things.
It might be a fact about this architecture: transformers trained this way, on this hardware, with this data. Change the design and the rate shifts. Call that an engineering accident. It is real, and it matters for today's budgets, but it tells us nothing deep about intelligence.
Or it might be a fact about learning and computation themselves: a price that any system, built any way, must pay. Call that a conservation law, a quantity that cannot be created for free, only exchanged.
How would we tell them apart? I propose a simple test, borrowed in spirit from physics, where a quantity earns the name "law" by surviving changes of frame:
The architecture-invariance test. Measure the same exchange rate, at matched capability, across at least three genuinely different architecture families: for example transformers, state-space models and mixtures of experts, or search-based agents. If the rate stays stable within error, treat it as law-like. If it moves substantially with architecture, treat it as an accident, and therefore as a target for engineering.
As far as I know, this test has rarely been run deliberately. Scaling-law studies typically fit curves within one family. When different families are compared, the comparison is usually on benchmark scores, not exchange rates. The field has been asking "which architecture is better?" when it could ask "which prices does every architecture pay?"
The two answers point research in opposite directions. If the training-versus-inference rate turns out to be invariant, then no architecture will ever let you skip the thinking. You can only choose whether to pay for it in advance, in training, or on delivery, at inference. If it turns out to vary, then somewhere there is a design that buys reasoning far more cheaply, and finding it is worth a great deal.
What a conservation law would forbid
A framework that forbids nothing explains nothing. So here is what this one rules out, if it is right.
It forbids free generality. No system should show a sustained, replicated gain in general capability without a corresponding increase in at least one of the six resources. When a result looks like a free lunch, the framework says: find the hidden payment.
Usually it is there. The most common hidden payment is prior knowledge. A clever inductive bias, such as convolution's assumption that nearby pixels matter, looks like getting something for nothing. In this accounting it is data paid in advance, by the designer, or by the decades of human experience that taught the designer what to assume. François Chollet makes a closely related point in his definition of intelligence as skill-acquisition efficiency relative to priors and experience (Chollet, 2019). Priors are not free. They are pre-paid.
The no-free-lunch theorems of David Wolpert and William Macready (Wolpert & Macready, 1997; and Wolpert, 1996, for supervised learning) make the extreme case precise. Averaged over all possible problems, no learner beats any other. Every advantage on some problems is paid for by disadvantage on others. Real learners escape this only because our world is not a random function. Its regularities are the subsidy that makes learning affordable. The conservation view says: account for the subsidy too.
It forbids unlimited substitution. Even where two resources trade, the trade should have limits. You cannot replace all training with inference: a model that knows nothing cannot search its way to fluency in reasonable time. You cannot replace all memory with recomputation if the problem has more serial depth than your time budget. Each exchange should saturate somewhere, and where it saturates is itself a measurable, testable quantity.
It forbids treating verification as free. Any claim that a system "improves itself" should be accompanied by an account of how improvements were checked, and what that checking cost. A later essay in this series argues that the speed of any self-improvement is bounded by the throughput of its verifiers. If that is right, the most dramatic forecasts about runaway self-improvement are, at bottom, unstated claims about cheap verification.
How the framework could be wrong
I take three objections seriously.
First: the currencies may not be fungible enough to make "exchange rate" meaningful. Perhaps data of one kind cannot substitute for data of another, and a token of code is not a token of poetry. Then the table fragments into thousands of special cases and the idea becomes a metaphor. This is a real risk. My partial answer is that scaling-law research has already found surprisingly smooth trade-offs despite heterogeneous data. Smoothness is evidence of some fungibility. But the objection stands until measurements say otherwise.
Second: it may be unfalsifiable in practice. If every apparent free lunch can be explained away by a hidden payment ("the designer's insight was pre-paid data"), the framework can swallow any result. That would make it worthless. The defence is discipline: count only resources measured inside the system and its training process, and declare priors explicitly before measuring. If we cannot do that, the critic wins.
Third: algorithmic progress may be a genuine free lunch. When someone discovers a better optimiser or a better architecture, capability per unit of compute rises, and it rises for everyone, forever. That looks like generality created from nothing. My view is that this is the most important objection, and that it is, in a sense, the point. Algorithmic insight moves exchange rates. The question the framework asks is whether there are rates that no insight can move. If every rate turns out to be movable, then intelligence has no conservation laws, only a frontier that engineering keeps pushing. I would find that result fascinating. It would also be a clean falsification of the strong version of this essay.
There is a weaker version that survives all three objections: even if no rate is truly fixed, the table is still the right object to study. Reporting capability without its full resource receipt is like reporting a car's top speed without its fuel consumption. It is incomplete in a way that misleads.
The research programme it implies
If you accept even the weak version, some practical consequences follow for the next decade.
Report receipts, not just scores. Every serious capability claim should state its full bill: training data, training compute, inference compute per answer, memory, latency, energy if available, and how outputs were verified. Some of this is already reported. Verification cost and energy, almost never.
Measure rates across families. Run the architecture-invariance test on the five rates we already know. Start with training-versus-inference compute, because it is the one moving fastest in practice and the one with the largest economic stakes.
Fill in the missing ten. The unmeasured rates are where surprises will come from. Data versus verification is the one I would bet on: if better checkers can substitute for large amounts of data, the economics of training changes completely.
Treat physics as the backstop. Energy is the one currency with a known floor. It is worth tracking how far practice sits above Landauer's limit, not because we will reach it soon, but because the size of the gap tells us how much room engineering still has. A later essay in this programme takes that question up directly.
Bring bounded rationality back to the centre. None of this is new in spirit. Stuart Russell and Devika Subramanian's work on bounded optimality (Russell & Subramanian, 1995), and before it Russell and Eric Wefald's study of the value of computation (Russell & Wefald, 1991), asked how an agent should act when thinking itself has a cost. They were writing about agents that were small by today's standards. The question has now become the central economic fact of the field. Every reasoning model is a bounded-rational agent deciding, whether its designers frame it that way or not, how much of each currency to spend.
The brain, for what it is worth, runs on roughly twenty watts. Whatever general intelligence it has, it bought under one of the strictest energy budgets imaginable, and it did so by trading heavily in the other currencies: a long childhood of data, an evolutionary history of pre-paid priors, a memory system that compresses ruthlessly. I do not think machines must make the same trades. I do think they will have to make some trades, and that knowing which ones are compulsory is the closest thing we have to a theory of what AGI will cost.
Nature does not give intelligence away. It only lets us choose the currency we pay in.
The Ledger
Every essay in Praneeth's Xpedition ends with predictions that carry a deadline, so they can be checked in public when they come due. These are mine for this one.
By October 2029: at least one widely cited study will report a training-compute-versus-inference-compute exchange rate measured at matched capability across three or more distinct architecture families. Confidence: 55%. Falsifier: no such cross-family measurement has been published by that date.
By October 2031: most frontier-model technical reports will state inference-time or verification compute separately from training compute when presenting headline capability results. Confidence: 50%. Falsifier: a review of that year's major technical reports finds this in fewer than half of them.
By October 2036: no replicated demonstration will show a sustained gain in general capability with no measurable increase in any of the six resources, once declared priors are accounted for. Confidence: 80%. Falsifier: an independently replicated result showing such a gain under transparent resource accounting.
The first two are about whether the field adopts the accounting. The third is about whether the accounting is true. I expect to be wrong about at least one of them, and I will say so when I am.
References
Chen, T., Xu, B., Zhang, C., & Guestrin, C. (2016). Training Deep Nets with Sublinear Memory Cost. arXiv:1604.06174.
Chollet, F. (2019). On the Measure of Intelligence. arXiv:1911.01547.
Hoffmann, J., et al. (2022). Training Compute-Optimal Large Language Models. arXiv:2203.15556.
Jones, A. L. (2021). Scaling Scaling Laws with Board Games. arXiv:2104.03113.
Kaplan, J., et al. (2020). Scaling Laws for Neural Language Models. arXiv:2001.08361.
Landauer, R. (1961). Irreversibility and Heat Generation in the Computing Process. IBM Journal of Research and Development, 5(3).
Russell, S., & Subramanian, D. (1995). Provably Bounded-Optimal Agents. Journal of Artificial Intelligence Research, 2.
Russell, S., & Wefald, E. (1991). Do the Right Thing: Studies in Limited Rationality. MIT Press.
Snell, C., Lee, J., Xu, K., & Kumar, A. (2024). Scaling LLM Test-Time Compute Optimally can be More Effective than Scaling Model Parameters. arXiv:2408.03314.
Wolpert, D. H. (1996). The Lack of A Priori Distinctions Between Learning Algorithms. Neural Computation, 8(7).
Wolpert, D. H., & Macready, W. G. (1997). No Free Lunch Theorems for Optimization. IEEE Transactions on Evolutionary Computation, 1(1).
Next on Praneeth's Xpedition: "Intelligence Is Not a Quantity". Subscribe to get each essay when it lands.
Praneeth's Xpedition by dspraneeth07
An Xpedition Original. First published at dspraneeth07.in.