The NOOPS Lexicon

Plain English. Attention is the mechanism inside a transformer that lets the model weigh every token against every other token to decide what matters. It is what gives a model its sense of context. The catch: comparing everything to everything is quadratic in the length of the input — double the context and the work roughly quadruples.

Why it moves money. That quadratic cost is the hidden meter behind inference bills. It is why long context windows are expensive, why the KV cache eats memory, and why serving a million-token prompt costs far more than a thousand-token one. Every trick that flattens attention's cost curve — sparse, linear and flash variants — translates directly into margin, and every provider chasing cheaper long context is really fighting this one equation.

What to watch. Whether the industry escapes the quadratic. Ballooning context windows and cheaper long-context models suggest engineering is winning at the margin; a true linear-cost replacement for attention would be a genuine architecture event, not an optimisation.

From the signals. DeepSeek shipped a 1M-token context window, the kind of scale attention's cost once forbade. A weekend debate over the context window as working memory is, underneath, an argument about attention.

Plain English. Generating one token at a time, each conditioned on everything before it. This is how nearly every language model works: the answer isn't planned then typed — it is committed to word by word, left to right, and the first token constrains everything after it.

Why it moves money. Sequential generation is the structural bottleneck of the inference business. Output speed is capped by how fast tokens can be produced one after another, which sets latency floors for agents, makes long outputs expensive, and created a whole engineering economy of workarounds — speculative decoding, caching, batching — that inference providers compete on. The architecture challengers (diffusion and other parallel-generation schemes) are, at bottom, attacks on autoregression's cost structure. Anyone modelling inference margins is, knowingly or not, modelling the consequences of one-token-at-a-time.

What to watch. Whether parallel-generation architectures reach quality parity on long structured output. Autoregression has survived every announced disruption so far; watch measured quality at speed, not launch claims.

From the signals. Mira OS on transformers: the first token commits the trajectory. Orthrus: a dual architecture unifying autoregressive fidelity with diffusion parallelism.

Plain English. The algorithm every neural network trains with: after the model makes an error, backpropagation works backwards through the network computing how much each weight contributed, and nudges billions of them accordingly. Popularised in 1986; still unreplaced.

Why it moves money. Backpropagation's mechanics quietly dictate the shape of the AI hardware market. Training requires running the network forwards, storing intermediate results, then flowing gradients backwards — which is why training demands far more memory than inference, why GPUs are built around memory bandwidth, and why training and inference are diverging into separate chip markets with separate economics. When analysts talk about the memory wall or HBM scarcity, they are describing constraints backpropagation imposes. It is also a single point of intellectual concentration: the entire industry trains one way, and any commercially viable alternative — several are researched, none deployed at scale — would redraw hardware requirements overnight.

What to watch. Alternatives leaving the lab: forward-only methods and other schemes that promise training without the backward pass's memory bill. Treat any claimed at-scale replacement as extraordinary until a frontier-class model trains with it.

Further reading. Rumelhart, Hinton & Williams, Learning Representations by Back-propagating Errors (Nature, 1986)

Plain English. Catastrophic forgetting is what happens when you train a neural network on something new and it abruptly loses what it already knew. Because a model stores everything in the same shared weights, updating them for a fresh task can overwrite the patterns that encoded the old ones. It is the reason models are trained once, in bulk, rather than topped up day to day.

Why it moves money. It is a structural tax on the industry's business model. Because a deployed model cannot safely keep learning from its own use, labs must periodically retrain from scratch — an enormous capital event — instead of improving a model cheaply and incrementally. It also caps how personalised a single model can become without a fleet of expensive fine-tunes. It is the failure mode that continual learning has to defeat to unlock cheaper, always-current models.

What to watch. Any credible method that lets a model absorb new information without degrading old performance. That is the unlock that would turn training from a recurring megaproject into something closer to ongoing maintenance — and would reset the economics of keeping a model current.

Plain English. A model writing out intermediate reasoning steps before its answer — thinking on paper. "Reasoning models" are models trained to do this at length, and much of the capability jump since 2024 is chain of thought plus reinforcement learning, not new architecture.

Why it moves money. Twice over. First, the reasoning is made of tokens and tokens are billed — chain of thought is a direct driver of inference demand, the mechanism behind rising cost-per-task even as cost-per-token falls. Second, a legible trace is the main window auditors, safety teams and regulators have into why a model did something; if reasoning drifts into compressed or latent forms humans cannot read, an entire oversight approach loses its instrument, with regulatory consequences that touch deployment timelines.

What to watch. Whether traces stay legible and faithful — research already argues the written trace is not reliable evidence of the actual computation — and whether latent-reasoning models that skip words entirely reach production.

From the signals. Two ICML papers argued the reasoning trace is not the evidence of alignment. A site claimed frontier reasoning can be recovered from encrypted traces. A 150M-parameter model reasons without words at $0.0007 per task.

Further reading. Wei et al., Chain-of-Thought Prompting (2022)

Plain English. Continual learning — also called online or lifelong learning — is the unsolved problem of a model that keeps improving from the work it does, updating its own weights as it goes, rather than being frozen the moment training ends. Today's models don't do this: they ship fixed, and any "learning" during use lives outside the weights, in agent memory and the harness. The obstacle it has to overcome is catastrophic forgetting, where new training overwrites old skills.

Why it moves money. It caps the labour-substitution thesis: an employee who never learns from experience has a ceiling, however capable on day one. A model that genuinely learned on the job would compound in value with use instead of going stale, and whoever cracks it changes agent economics outright. Until then, the workarounds — retrieval, longer context, harness memory — are themselves becoming products, and test-time training, where weights update during use, is one claimed path through.

What to watch. A demonstrated, durable on-the-job improvement without a full retraining run — and whether it survives independent replication. Treat "our agents learn from your business" as harness memory until the weights actually move.

From the signals. Prime Intellect shipped a harness built on a "Continual Harness" abstraction — self-improvement at the scaffold, not the weights. Test-time training would give each user their own model, and its own cost.

Plain English. Models that generate by starting with noise and refining the whole output in parallel over several passes — rather than producing it one token at a time. The technique behind image and video generation, now being applied to text.

Why it moves money. Parallel generation is a throughput play. An autoregressive model's speed is capped by producing tokens sequentially; a diffusion language model refines everything at once, and the claimed speeds — over a thousand tokens a second on a single GPU — would rewrite inference economics if quality holds. For agents that consume millions of tokens per task, generation speed is a cost and latency line, so an architecture that trades a little quality for a large multiple of throughput has a real market even if it never leads benchmarks.

What to watch. Independent quality evaluations at the claimed speeds. Vendor demos measure the easy half; the question is whether diffusion text holds up on long, structured outputs where autoregressive models are strongest.

From the signals. DiffusionGemma claimed ~1,500 output tokens a second on a single H100. Mercury 2.5 claimed frontier-lite quality at 1,107 tokens a second. O'Reilly read Google's reshuffle as a bet on diffusion over the frontier.

Further reading. Ho et al., Denoising Diffusion Probabilistic Models (2020)

Plain English. Training a cheaper model to imitate an expensive one by learning from its outputs at scale. The student doesn't need the teacher's data or code — just enough of its answers.

Why it moves money. Distillation is why a capability lead may not be a durable moat. Every frontier model exposed through an API is, to some degree, a free teacher for its competitors — which compresses the price premium a leader can charge and shortens the window in which training costs can be recouped. It is the mechanism behind near-frontier models at a tenth of the price, and it is now a geopolitical allegation, not just a technique.

What to watch. Whether labs can actually detect and block it (rate limits, output watermarks, account vetting), and whether the price gap between frontier and near-frontier keeps narrowing anyway. If the gap narrows while usage of the cheap tier grows, distillation is winning regardless of what anyone announces.

From the signals. The NSA, CISA and FBI accused Chinese AI firms of industrial-scale distillation — an accusation, not a court finding. An independent probe moved Qwen 18 points toward GPT-5.5 Pro with a prefill trick, hinting at its teacher. Anthropic closed a documented distillation route for new accounts.

Plain English. An ability that shows up in a larger model without having been deliberately trained — apparently absent at one scale, present at the next. Whether emergence is real or an artefact of how we measure it is genuinely contested: one influential paper argues many "jumps" are mirages created by all-or-nothing scoring.

Why it moves money. Emergence is unpriced optionality in both directions. On the upside, a training run can return capabilities nobody paid for; on the downside, it means labs cannot fully specify what they are shipping — offensive cyber skill arriving unbidden is now a documented pattern, and it drives regulatory exposure, deployment pauses and disclosure obligations that hit revenue timing. A lab that cannot rule out a dangerous capability in its next model is telling you its own product roadmap has error bars.

What to watch. System cards and evaluation reports where labs describe capabilities they did not train for — and the measurement debate, because if emergence is mostly a metric artefact, capability forecasting gets easier, not harder.

From the signals. GLM-5.3 shipped open, its makers calling the cyber gain emergent. Anthropic's Mythos showed emergent offensive cyber capabilities not explicitly trained. OpenAI could not rule out critical cyber capability in its next model.

Further reading. Wei et al., Emergent Abilities of Large Language Models (2022) · Schaeffer et al., Are Emergent Abilities a Mirage? (2023)

Plain English. Taking a trained model and training it further on your own examples so it behaves your way — supervised fine-tuning (SFT) when the examples are curated input-output pairs. Techniques like LoRA make it cheap by adjusting a small fraction of the weights. Distinct from prompting (no weight changes) and from retrieval (giving the model documents at question time).

Why it moves money. Fine-tuning is the load-bearing claim of the "specialised models" thesis: that enterprises will pay for models adapted to their domain rather than renting the general frontier. The countervailing force is brutal — each frontier release absorbs capabilities that fine-tuned models were sold to provide, so a fine-tuning vendor is in a race against its own substrate's improvement. The viable niches are where data is private, behaviour is regulated, or inference must be cheap and local.

What to watch. Whether fine-tuned small models hold measurable advantages over each new general frontier model on the customer's own tasks — the comparison that decides if this is a product category or a feature.

From the signals. Mistral Forge: the Bitter Lesson comes for enterprise fine-tuning.

Further reading. Hu et al., LoRA: Low-Rank Adaptation (2021)

Plain English. Formal verification is having a machine check a proof or a program line by line, so that correctness is guaranteed rather than merely asserted. The check is exhaustive: if it passes, there is no untested case left. It is how you get reliable output from an unreliable generator — the model can hallucinate all it likes, because nothing unproven survives the checker. (Getting informal mathematics or a specification into checkable form, autoformalisation, is the translation step that feeds it, usually into Lean.)

Why it moves money. This is the claimed escape from hallucination in high-stakes domains, and it has become a funded startup category rather than an academic niche. The economic frame: verification does for AI output what mass production's quality control did for manufactured goods — it makes the output tradeable by strangers. Software, mathematics and eventually safety-critical engineering get a tier of AI work that can be certified, insured and sold, while unverifiable domains stay on the slower trust curve.

What to watch. The cost curve of formalisation — machine-checked results are landing at scales unthinkable two years ago — and whether verification moves from mathematics into the mainstream software supply chain.

From the signals. Claude formalised Fermat's Last Theorem in 11 days and 13 million lines of Lean. OpenAI claimed a Lean-certified Navier–Stokes proof; a priority dispute erupted. Formal verification is to the AI era what mass production was to industry.

Further reading. The Lean theorem prover

Plain English. One large model, pretrained broadly, adapted to many downstream tasks — the foundation others build on. The term was coined at Stanford in 2021 to name the shift from task-specific models to general substrates. It now travels beyond language: labs are minting foundation models for biology, weather, materials and 3D worlds.

Why it moves money. Foundation models carry platform economics. Whoever owns the substrate collects rent from everything built on it, which is why "we are building the foundation model for X" is the highest-multiple pitch in venture — each new domain is a claim that platform economics will replay there. The claim is checkable: a genuine foundation model beats task-specific baselines across its domain, on measured performance, not on vision decks.

What to watch. Whether domain foundation models post measured wins over specialised incumbents — hit rates, forecast skill, discovery counts — and whether adaptation on top of them stays cheap enough to leave room for an application layer.

From the signals. OpenAI launched biology-tuned GPT-Rosalind. World Labs launched Atlas, an omni world model over text, image, video and 3D. Anthropic reported protein-binder hit rates above its stated field norm.

Further reading. Bommasani et al., On the Opportunities and Risks of Foundation Models (2021)

Plain English. A model picking up a task from examples or instructions in the prompt itself — no retraining, no weight changes. Show it three worked examples and it does the fourth. The catch: the learning evaporates when the conversation ends. Nothing is retained.

Why it moves money. In-context learning is why context windows became an arms race and why "just prompt it" displaced a lot of anticipated fine-tuning spend. But its impermanence is one of the deepest constraints in the AI economy: a system that cannot accumulate experience on the job caps the labour-substitution thesis at tasks a competent stranger could do with a briefing document. The gap between in-context learning (instant, temporary) and weight updates (slow, permanent) is where a whole product layer lives — memory systems, retrieval, context engineering — and where labs are aiming next.

What to watch. Anything that makes learning persist: test-time training, continual-learning research, memory architectures. Genuine on-the-job learning would be a step-change in what AI can replace, and pricing.

From the signals. Two opposite readings of the context window as working memory. Test-time training would give each user their own model — and its own cost.

Further reading. Brown et al., Language Models are Few-Shot Learners (2020)

Plain English. The internal space a model represents meaning in — a high-dimensional map where every input becomes a vector of numbers, and where nearness stands for similarity. "Cat" and "kitten" sit close together; a translation is a short move in one direction. The model never works with words or pixels directly, only with positions in this space.

Why it moves money. The latent space is where a model's real capability and its defensibility live. Two systems can share an architecture and still differ entirely in the geometry they learn, and that geometry is what training buys. It is also where the leaks are: because these spaces turn out to be more universal than assumed, a competitor who captures embeddings can often reconstruct sensitive attributes, which turns a vector store into a liability an investor should price.

What to watch. Whether "our data is our moat" survives contact with the finding that embeddings translate across models. If one lab's latent geometry can be aligned to another's without the original data, the moat is thinner than the pitch deck claims.

From the signals. Embeddings translate across model spaces, exposing vector databases — the universal-geometry result, and why a latent space is not the private asset it looks like. See also /invest/embeddings.

Plain English. Lean (currently Lean 4) is a proof assistant: software that checks a mathematical or logical argument step by step and certifies it holds, with no gaps. When a proof is written in Lean, "verified" means machine-checked, not merely peer-reviewed. It is increasingly the tool used to confirm that AI-generated mathematics is actually correct.

Why it moves money. Lean turns a model's confident-sounding output into something you can trust without trusting the model. That matters commercially wherever a wrong answer is expensive — proofs, and by extension code, chip designs and financial logic — because it replaces human review with a certainty check the machine cannot fake. It is the concrete substrate under formal verification: the "certified" in a Lean-certified proof is the whole point.

What to watch. How much frontier mathematics gets Lean-certified rather than merely claimed, and whether the pattern spreads from maths into verifiable software and hardware. A claim without a Lean proof is a press release; a claim with one is a result.

From the signals. OpenAI's Lean-certified Navier–Stokes proof — and the priority dispute it triggered. Claude formalised Fermat's Last Theorem in 13 million lines of Lean. Star Fleet ran twenty agentic harnesses at open maths, every result checked by Lean 4.

Plain English. Low-rank adaptation: instead of retraining a whole model to specialise it, you train two small add-on matrices per layer — an adapter — and leave the original weights untouched. Adapters are cheap to train, tiny to store, and swappable, so one base model can wear many specialisations.

Why it moves money. LoRA made fine-tuning a commodity. It is why open-weight ecosystems can spawn six-figure derivative counts — Qwen alone has 151,448 derivative repositories on Hugging Face — and why "we fine-tuned it on our data" is now table stakes rather than a moat. The open valuation question is whether fine-tuned specialisation holds value at all: the Bitter Lesson argument says each general-model generation erodes the specialist's edge.

What to watch. Whether fine-tuned niche models keep beating the next general release on their home turf — and for how many months at a time.

From the signals. Qwen is now the base layer: 151,448 derivatives on Hugging Face, with fine-tuning-ready builds a top publisher. Mistral Forge and the Bitter Lesson question over enterprise fine-tuning moats.

Further reading. Hu et al., "LoRA: Low-Rank Adaptation of Large Language Models" (2021).

Plain English. Emerging lab jargon for the phase between pretraining and final post-training: continued training on curated, capability-targeted data — long-document corpora to extend context, code and maths to prep for reasoning RL, domain infusions. Less glamorous than either neighbour, increasingly where recipes are won.

Why it moves money. Mid-training is part of the quiet migration of competitive advantage from compute scale to recipe design. Two labs with identical clusters and similar raw corpora can land in very different places depending on what they feed the model in this phase and in what order — which makes recipe secrecy a moat precisely because compute is levelling. It also complicates diligence: "trained on X billion tokens" tells you nothing about the sequencing that made the difference, and phase vocabulary varies enough between labs that stage-by-stage comparisons are mostly guesswork from outside.

What to watch. Open releases that publish full multi-stage recipes, because each disclosure converts a rival's secret into common knowledge — and shortens the half-life of recipe moats generally.

From the signals. Kimi K3 shipped the whole recipe, not just the weights.

Plain English. An architecture where the model holds many specialist sub-networks ("experts") but routes each token through only a few of them. A model can therefore be enormous on paper while doing a fraction of the work per token — total parameters set what it can know; active parameters set what each token costs.

Why it moves money. MoE is the trick behind cheap frontier-adjacent models: near-frontier quality at a fraction of the serving compute. It also makes headline parameter counts actively misleading — a "552B model" running 30B active parameters per token has the cost profile of a much smaller model but the memory footprint of a huge one, which shapes which hardware can serve it and whose margins survive. Comparing models by total parameters is the retail error; the professionals compare active parameters and memory.

What to watch. Active-parameter counts in model cards, and the dense-versus-MoE crossover: cases where well-trained dense models beat far larger sparse ones tell you routing is not free.

From the signals. DeepSeek released V4.1-Flash: 552B MoE, 1M context, MIT-licensed weights. Qwen3.6-27B, a dense model, outperformed a 397B MoE on coding. Qwen 3.6 approached the frontier on 3B active parameters.

Further reading. Shazeer et al., Outrageously Large Neural Networks (2017)

Plain English. Capability that already exists but isn't yet usable. An overhang is latent capacity waiting to be released — compute built but not applied, or abilities sitting inside current models that nobody has drawn out. Unhobbling, a term from Leopold Aschenbrenner's "Situational Awareness", is the release mechanism: better harnesses, tools, memory and prompting that unlock what the weights could already do. It is why products keep improving between training runs, without any new model.

Why it moves money. Overhang breaks the intuition that AI progress equals model releases. A serious slice of recent gains came from harnesses, not weights — so even if frontier training stalled tomorrow, years of deployable improvement would remain, which reshapes both the bear case (a training plateau is not an industry plateau) and the safety debate (a development pause does not pause capability growth). It also says where application-layer margin comes from: unhobbling gains are captured by whoever ships the harness, not whoever trained the model.

What to watch. Capability gains at a fixed model — time-per-task and eval movement attributable to harness changes alone — and deliberate hobbles being priced: guardrail and safety taxes measured, argued over, and walked back.

From the signals. A US$100,000 contest asks what happens if AI progress stopped today — the overhang counterfactual, funded seriously. Fable's guardrail walk-back framed safety as a measurable harness tax.

Further reading. Leopold Aschenbrenner, "Situational Awareness".

Plain English. The numbers a model learns during training — billions of them — that encode everything it knows. "Weights" and "parameters" are the same thing; a "70B model" has seventy billion of them. Shipping the weights is shipping the model.

Why it moves money. Weights are the asset. Training converts hundreds of millions of dollars of compute into a file, and everything about that file's economics follows from parameter count: how much memory it needs, what hardware can serve it, what it costs per token. Weights are also the theft target, the export-control object and the open-source battleground — "open weights" means the asset is free and the business must live elsewhere. But count is a size measure, not a quality measure: parameter-count comparisons across architectures and generations mislead more than they inform.

What to watch. Capability per parameter. The trend of small models doing work assumed to need frontier scale is the quiet deflationary force in AI — it moves inference from data centres to devices and undercuts every business plan priced on big-model serving.

From the signals. Kimi K3 became the first open model at 2.8 trillion parameters. A 150M-parameter model reasoned at $0.0007 per task. A 744-billion-parameter model now runs on 25GB of consumer RAM.

Plain English. Everything done to a model after pretraining: supervised fine-tuning on curated examples, reinforcement learning from feedback or verifiable rewards, safety training. Pretraining produces a raw text predictor; post-training turns it into a product that follows instructions, reasons at length and declines to help with bioweapons.

Why it moves money. The differentiation between frontier labs has migrated here. Pretraining compute is increasingly available to anyone with capital; the post-training recipe — what data, what rewards, in what order — is the part labs guard. It is also far cheaper than pretraining, which means capability gaps can close faster than capex comparisons suggest: a rival doesn't need your cluster to copy your behaviour, only a good enough recipe.

What to watch. How much of a lab's compute and headcount shifts from pretraining to post-training, and how quickly open releases replicate closed-model behaviour. When the recipe leaks or gets published, the gap it protected closes on a timescale of months.

From the signals. Kimi K3 shipped the whole training recipe, not just the weights — recipe disclosure as a competitive act. GLM-5.3 shipped open with its makers calling the cyber capability gain emergent, a reminder that post-training doesn't fully control what surfaces.

Plain English. The first and biggest phase of building a model: feeding it a vast corpus of text and having it learn to predict the next token, over and over, until statistical prediction starts to look like knowledge. Everything a model "knows" about the world it mostly learned here.

Why it moves money. Pretraining is where the capital goes — the multi-hundred-million-dollar training runs, the GPU clusters, the power contracts. A lab's pretraining bill is the entry ticket to the frontier, so anything that changes its cost changes who can compete. Efficiency claims are therefore moat claims: if a smaller player can pretrain near-frontier capability cheaply, the incumbents' spend stops being a barrier and starts being a liability.

What to watch. The claimed cost of a frontier-class pretraining run, and whether efficiency recipes survive independent replication. Falling entry costs devalue incumbency; rising ones entrench it.

From the signals. Magic claimed a pretraining recipe roughly 50x more compute-efficient than DeepSeek V4 Pro's — a claim, not yet a replication. A small-scale study found data quality drove 12x of pretraining gains against 3.7x from model tweaks. SemiAnalysis argues sovereign pretraining is becoming a nation-state calculation.

Plain English. Storing a model's weights at lower numerical precision — fewer bits per number — so the same model takes a fraction of the memory and runs on smaller, cheaper hardware, at the cost of some accuracy. Think of it as compression for models: a 4-bit build of a model can be around a quarter the size of the 16-bit original and remain usable.

Why it moves money. Quantisation is the mechanism that moves near-frontier capability out of the data centre and onto hardware a customer already owns. Every step down in precision widens the set of machines a given model fits on, which strengthens the local-inference alternative to metered APIs and shrinks the hardware bill for anyone serving open-weights models. It converts a lab's headline release into something that runs on a laptop within days.

What to watch. Measured accuracy retention at aggressive precision (independent numbers, not the quantiser's), and whether labs ship quantised builds on day one — that is a distribution strategy, not an afterthought.

From the signals. Qwen3.8-27B shipped an FP8 quantised build within hours of release. GLM-5.3's 2-bit build is 83% smaller at roughly 81% top-1 accuracy, on Unsloth's documentation, and fits on a Mac Studio. A 17GB quantised build scored 52 on Artificial Analysis and ran on a MacBook Pro.

Plain English. The idea that an AI system improves the systems that build AI — writing the training code, designing the experiments, tuning the hardware — so each generation arrives faster than the last. In the strong version the loop closes entirely and progress compounds without humans. Nothing public today is the strong version: what labs actually report is AI helping engineers with narrow parts of the pipeline.

Why it moves money. RSI is the assumption hiding inside the largest valuations. If the loop compounds, today's leader converts capital into capability faster than anyone can catch up, and a US$2tn valuation is arithmetic; if it doesn't, model-making stays an ordinary R&D business with rising input costs. Claims of "the model helped build itself" are therefore worth more scrutiny than any benchmark score.

What to watch. Whether the claim survives being restated boringly. "Automated performance engineering" — real, useful, bounded — fits most published evidence as well as "self-improvement" does. Ask what fraction of the gain is attributed to the model, measured how, against what baseline.

From the signals. Tencent said Hy4 helped train itself and put 31.8% on the throughput — its framing, with the boring restatement fitting the same facts. Ornith-1.5 put the harness inside the training loop, the most direct public test of the mechanism so far.

Plain English. Reinforcement learning (RL) trains a model by reward and penalty over many attempts rather than by showing it correct answers. RLHF — reinforcement learning from human feedback — is the variant where the reward comes from humans rating outputs. RLHF is what made chatbots polite and useful in 2022; RL against harder, checkable objectives is what makes reasoning models capable now.

Why it moves money. These are different cost structures. RLHF runs on a human-labour supply chain — annotation firms, preference raters — which is a real, investable (and displaceable) market. Outcome-based RL runs on compute and environments instead, and labs are shifting spend towards it because machine-checkable rewards scale where human raters don't. The distinction matters: a lab saying "we scaled RL" is claiming capability; "we scaled RLHF" is mostly claiming behaviour.

What to watch. The share of training compute going to RL, disclosed or estimated, and whether annotation vendors' revenue growth survives the shift to verifiable and model-generated rewards.

From the signals. A single-rollout async RL paper claimed stability gains over GRPO — the algorithm layer is still moving. Dan Luu asked why labs haven't built RL environments for testing.

Further reading. Christiano et al., Deep RL from Human Preferences (2017) · Ouyang et al., the InstructGPT paper (2022)

Plain English. Simulated tasks and workplaces — a fake codebase, a mock browser, a synthetic negotiation — where a model practises and gets graded, so reinforcement learning has somewhere to happen. If verifiable rewards are the engine, environments are the fuel.

Why it moves money. Environments are to this era what training data was to the last one: the scarce input everyone suddenly needs, with a supply chain forming in plain sight. Labs are paying for realistic, hard, gradable task worlds, and a startup category has appeared to sell them — while data that doubles as an environment (recorded gameplay, logged workflows) is being repriced as a moat. The open question is whether environments stay a purchasable commodity or become in-house infrastructure the way frontier data pipelines did.

What to watch. Prices and buyers in the environment supply chain, and whether labs verticalise. Also the quality problem: an agent trained in a shallow environment ships shallow competence, so environment realism becomes a due-diligence question on every "trained with RL" claim.

From the signals. Dan Luu asked why AI labs haven't built RL environments for testing. US$2.3bn went to a lab whose moat is gameplay data.

Plain English. Reinforcement learning from verifiable rewards: training a model against tasks where a machine can check the answer — the maths proof compiles, the code passes tests, the number matches. No human raters, no learned judge; the reward is ground truth.

Why it moves money. RLVR is the engine of the reasoning-model era, and it draws a bright line across the economy: domains with checkable answers (code, maths, parts of law and finance) can be trained on at machine scale and automate first; domains where quality is a matter of taste improve much more slowly. "Is it verifiable?" has become a serviceable one-question screen for which industries face automation on what timeline — and for which AI products can actually deliver claimed reliability rather than asserting it.

What to watch. Progress in non-verifiable domains, where labs substitute learned judges and rubrics — and reward hacking, because a model trained against a checker learns to satisfy the checker, which is not always the same as being right.

From the signals. Star Fleet set twenty agentic harnesses on open maths problems, checked by Lean 4. The economics of recursive self-improvement meets verification design.

Further reading. Lambert et al., Tülu 3 — the paper that named RLVR (2024) · DeepSeek-R1 (2025)

Plain English. How much data a learner needs to gain a unit of capability. Humans are startlingly sample-efficient — a teenager learns to drive in twenty hours; models learn from oceans of examples and still miss things a novice wouldn't. The gap is one of the deepest open problems in the field.

Why it moves money. Sample efficiency decides whether scaling keeps paying. Models have already read most of the useful internet; if capability requires ever more data and the data is exhausted, the scaling thesis hits a wall that compute cannot buy through. Everything currently propping that wall up — synthetic data, RL environments, data-quality curation — is a sample-efficiency workaround, and evidence that data quality now outbuys model tweaks repriced curation from janitorial work to core R&D. It also sets the value of proprietary data: the scarcer useful examples are, the more owning them is a moat.

What to watch. Measured capability gains attributed to data quality versus quantity, and progress in domains where data is inherently scarce — robotics being the canonical case.

From the signals. A small-scale study found data drove 12x of pretraining gains, model tweaks 3.7x. Xiaomi attacked robotics' data bottleneck with embodiment-free pre-training.

Plain English. The empirical finding that model capability improves smoothly and predictably as you add compute, data and parameters — so predictably that labs can forecast a model's quality before spending the money to train it. Kaplan and colleagues published the original curves in 2020; the Chinchilla paper corrected the recipe, showing most models were under-fed on data relative to their size.

Why it moves money. Scaling laws are the underwriting document for the entire AI capex cycle. Hundreds of billions in data centres, chips and power make sense only if more compute reliably buys more capability. Every revision matters: Chinchilla shifted value towards data; efficiency recipes shift it away from raw scale; and any genuine flattening of the curve would strand a great deal of capital.

What to watch. Whether each new frontier model justifies its compute multiple over the last one, and whether the gains are coming from scale or from recipe — the second is much harder to defend.

From the signals. OpenAI's chief scientist said no lab can responsibly keep scaling flat out. A small-scale study found data drove 12x of pretraining gains against 3.7x for model tweaks. Magic claimed a ~50x more compute-efficient pretraining recipe.

Further reading. Kaplan et al., Scaling Laws for Neural Language Models (2020) · Hoffmann et al., the Chinchilla paper (2022)

Plain English. A system improving by competing against copies of itself, generating its own opponents and its own training data as it goes. The technique behind AlphaGo's successors, which reached superhuman Go with no human games at all — each generation trains against the last, and the curriculum builds itself.

Why it moves money. Self-play is the proven escape from the human-data ceiling. A learner limited to imitating people tops out near the best person; one that plays itself has no such cap — that is what "superhuman" claims usually rest on mechanically. The constraint is that classic self-play needs a defined game: clear rules, a scoreboard, a symmetric opponent. The live investment question is how far it extends beyond games — into adversarial security training (attacker and defender models sharpening each other), negotiation, and models critiquing their own outputs. Where a domain can be made game-like, the human-data ceiling comes off; where it can't, incumbent data moats survive.

What to watch. Credible self-play results in open-ended domains without crisp win conditions. That is the boundary between a historic games technique and a general capability engine — and it hasn't convincingly moved yet.

Further reading. Silver et al., Mastering the Game of Go Without Human Knowledge (Nature, 2017)

Plain English. In a sparse (mixture-of-experts, MoE) model, only a fraction of the weights fire for any given token — the model routes each token to a few specialist "experts" out of hundreds. The sparsity factor is the ratio of total to active parameters: a 552B-parameter model activating 8–16B per token is doing frontier work at small-model running cost.

Why it moves money. Sparsity is the main trick behind cheap frontier-adjacent models, and it decouples the two numbers investors habitually conflate: parameter count (capability headline) and active parameters (serving cost). It also changes what hardware matters — sparse models are why a 744B model can run from a consumer machine by streaming experts off disk.

What to watch. Active-parameter counts in model cards, not headline sizes. Serving economics follow the active number; marketing follows the total.

From the signals. DeepSeek V4.1-Flash: 552B MoE activating 8B per token in prefill, 16B in decode. DeepSeek V4 delivered frontier-adjacent capability at a tenth of the memory. A 744-billion-parameter model now runs on 25GB of consumer RAM by streaming its experts.

Further reading. Fedus, Zoph & Shazeer, "Switch Transformers" (2021).

Plain English. Spending more computation when the model answers, not when it is trained — letting it think longer, try multiple approaches, or check its own work. The mechanism behind "reasoning" settings, and the third axis of scaling after model size and data.

Why it moves money. It moves cost from training capex to inference opex. A model that thinks for thousands of tokens before answering multiplies the compute — and the bill — per query, which is bullish for compute demand and awkward for anyone selling flat-rate access. It also makes capability a dial rather than a fixed property: the same model at different thinking budgets is effectively different products at different prices, and benchmark scores quietly depend on how much thinking the tester paid for.

What to watch. Tokens consumed per task, and whether extra thinking keeps buying accuracy or hits diminishing returns per domain. Score claims that don't disclose the reasoning budget are marketing.

From the signals. Harness choice moved Astra's ARC-AGI-3 score by 36 points at max reasoning. GLM-5.3 scored 60 on Artificial Analysis and paid for it in tokens. Kimi K3 thinks in code — and that is why token demand goes up.

Further reading. Snell et al., Scaling LLM Test-Time Compute Optimally (2024)

Plain English. A model that takes a small training step on the prompt it is answering, so its weights change as it works. Distinct from test-time compute (thinking longer with fixed weights): here the model itself is briefly, genuinely learning.

Why it moves money. Three consequences, per the analysis that put it on investor radar. Memory flattens: history folds into fixed-size weights instead of a KV cache that grows with context. Speed can improve — cited research on small models reports up to 2.7x. But serving inverts: once a model updates on your prompt, it is no longer the model that answered anyone else's, so one checkpoint serving millions becomes millions of slightly different models — a per-user cost structure no current inference business is built for.

What to watch. Whether any provider ships it at production scale, and what they charge for it — the per-user serving cost is the tell for whether the economics close.

From the signals. Test-time training would give each user their own model, and its own cost.

Further reading. Sun et al., "Learning to (Learn at Test Time)" (2024).

Plain English. Richard Sutton's 2019 essay observing that, over seventy years of AI research, general methods that scale with computation have always beaten systems built on hand-crafted human knowledge. Cleverness loses to scale — bitterly, because researchers keep betting on cleverness anyway.

Why it moves money. It is the most-cited idea in AI, and functionally a valuation tool. Any moat built on domain-specific engineering — curated features, expert rules, elaborate scaffolding around a model's current weaknesses — is a bet against the Bitter Lesson, and history says that bet loses when the next scaled-up general model absorbs the cleverness for free. It is also the intellectual licence for the capex boom: if scale reliably wins, buying compute is buying capability. The counter-case matters too — where physics, data scarcity or economics cap the scaling, specialised approaches keep their value, and knowing which regime you are in is the analysis.

What to watch. Each frontier release, watch which specialised products it absorbs — and note the domains where it keeps failing to, because those are where engineering moats are real.

From the signals. Mistral Forge: the Bitter Lesson comes for enterprise fine-tuning. The Inverse Bitter Lesson: why specialised software beats generalised. The RAM crisis: the Bitter Lesson hits physics.

Further reading. Sutton, The Bitter Lesson (2019)

Plain English. The fixed vocabulary of chunks — tokens — a model can read and write, and the space of all possible sequences over it. A model does not choose among words or ideas; at each step it chooses among the tens of thousands of tokens in its vocabulary, one after another. Everything a model can express is a path through token space. Distinct from latent space: token space is the discrete, visible alphabet; latent space is the continuous, internal map of meaning.

Why it moves money. Token space sets the metering unit and the cost floor. Every product is billed per token (see /invest/dollars-per-million-tokens), every context window is measured in tokens (see /invest/context-window), and vocabulary design decides how many tokens a given language or codebase costs to process — which is why non-English and code workloads can carry a quiet price premium.

What to watch. Tokeniser efficiency as a hidden margin lever: a model that represents the same text in fewer tokens is cheaper to run and to buy, without any change in intelligence. Watch for vocabulary changes framed as capability that are really cost engineering.

Further reading. The GPT tokeniser, explained

Plain English. The transformer is the neural-network architecture nearly every large language model is built on. Introduced in 2017, it reads a whole sequence at once rather than word by word, which is what let training scale onto thousands of GPUs in parallel. It is the substrate under GPT, Gemini, Claude and the open-weight models alike.

Why it moves money. The transformer's scalability is why the last decade of AI capital works at all: pour more data, parameters and compute into the same architecture and the model gets predictably better (see scaling laws). That predictability is what justifies multi-billion-dollar training runs and the entire GPU buildout. It also means the architecture itself is not the moat — everyone has it — so the value migrates to data, compute and distribution.

What to watch. Whether anything displaces it. Serious challengers so far (diffusion models for text, state-space models) have ended up either transformer-flavoured or niche. Its core cost driver is attention, which sets what context windows and the KV cache cost; a genuine successor would reset the hardware and training economics overnight.

From the signals. Etched bet its whole company on the transformer being permanent enough to etch into silicon. Qwen's latest open-weight frontier model ships yet another transformer variant.

Plain English. Models that learn how an environment behaves — predicting what happens next in a physical or simulated world, not just what word comes next in a sentence. The claimed path to AI that can act competently in space and time: robotics, autonomy, games, science.

Why it moves money. World models are the favourite differentiation pitch against the language-model incumbency — the argument that text prediction has a ceiling and the next scaling frontier is learned simulation. Capital is committing to that argument across robotics, video generation and "physical AI". They are also pitched as infrastructure for agents: a cheap simulated world to train and test in before touching the expensive real one, which makes world models a training-data play as much as a product.

What to watch. Transfer. The tell that separates the real thing from demo reels is measured performance on real-world tasks after training in the model's world — not the fidelity of the generated video.

From the signals. World Labs launched Atlas, an omni world model over text, image, video and 3D. Qwen open-sourced language world models for training agents. Odyssey's Agora-1 landed as world models moved below cohort attention.

Further reading. Ha & Schmidhuber, World Models (2018)

Plain English. A model given tools and a goal, running in a loop: read the situation, act, check the result, act again — for minutes or days, without a human approving each step. The model is the capability, the harness is the machinery, the agent is the running combination. Most 2026 growth stories are agent stories, because agents consume tokens at multiples of what a person typing into a chat box ever could.

Why it moves money. Demand forecasts, data-centre build-outs and lab valuations increasingly assume agentic volume — machines consuming inference around the clock rather than humans at keyboards. Agents are also the vehicle for the labour-substitution claims that anchor the largest numbers. Both stories depend on agents completing work someone pays for, not merely running.

What to watch. Revenue per agent, not activity per agent. Agent-workdays, token counts and session numbers are consumption measures; they establish cost, not value. Ask what fraction of agent runs produced an outcome a customer accepted.

From the signals. Goldman Sachs Research projects roughly 120 quadrillion tokens a month by mid-2030, over 80% of it agentic. OpenAI reports running 3.1 agent-workdays for every human workday — a runtime ratio, not an output ratio. Seven agents ran real businesses for 72 hours: US$12,431 in unsolicited invoices, $0 revenue.

Plain English. What an agent retains between sessions: facts about you, past decisions, project state. Distinct from the context window (working memory that vanishes when the session ends) — agent memory is the part deliberately written down and carried forward.

Why it moves money. Memory is the claimed moat of nearly every agent product: the longer it works with you, the harder you are to poach. But production practice keeps converging on aggressively simple substrates — versioned Markdown folders, portable zip-of-markdown formats — which commoditises the layer a wave of memory startups is priced on. Meanwhile labs are wiring memory across their own surfaces, which strengthens platform lock-in from the other direction.

What to watch. Whether memory stays a portable file you own or becomes provider-held state you can't export — that single design question decides where the moat sits.

From the signals. Memoryfields: a proposal to make agent memory a file format, not a pipeline. Extency: production agent memory is versioned Markdown folders, not vector databases. Claude's memory went cross-surface, with sensitive topics off by default.

Plain English. Letting AI agents write software: the model plans, edits files, runs tests and iterates inside a harness, with a human reviewing outcomes rather than keystrokes. "Vibe coding" — Andrej Karpathy's coinage — is the casual variant: describe what you want, accept what works, don't read the code.

Why it moves money. Coding is AI's first proven market and its largest token sink — by OpenAI's own account, Codex generates 99.8% of its weekly output tokens. It is also where labour substitution has real, auditable numbers: a full JavaScript-runtime port, a million lines in 11 days, for a reported API cost of about US$165,000.

What to watch. Verification cost, not generation cost. The Bun port passed the full test suite and still surfaced 19 regressions post-merge — review and testing are where the economics of agentic coding will be decided.

From the signals. Codex is 99.8% of OpenAI's weekly output tokens. Claude Code ported the Bun runtime from Zig to Rust in 11 days, with costs and regressions both on the record. The vibe-coding skills-decay panic mistakes the artefact for the value.

Plain English. Serving many users' requests through the same chips at the same time. One person's request leaves most of an accelerator idle; stacking dozens of requests together fills it. Batching is the unglamorous reason hosted inference is cheap.

Why it moves money. Utilisation is the margin engine of the API business. One widely shared argument puts hosted serving at roughly thirty times more resource-efficient than the same model running for a single user at home — a reported estimate, but the direction is not in dispute. Batching is also why capacity has a time-of-day price: off-peak tokens are cheaper because the batches are emptier.

What to watch. Off-peak and batch-tier pricing spreading across providers — the clearest public evidence that utilisation, not capability, is the binding constraint.

From the signals. The local-models argument is really an argument about batching economics: hosted serving's claimed ~30x resource-efficiency edge. Anthropic's capacity constraints produced "batch AI" and timezone arbitrage — off-peak allocation as policy.

Plain English. Agents that operate software the way a person does — looking at the screen, clicking, typing, driving a browser — rather than through purpose-built APIs. It is the bridge between chatbots and labour substitution, because most work still lives in interfaces built for humans.

Why it moves money. Whatever software an agent can operate, it can staff. Platform owners are moving to own the surface: Apple is building toward an agent that operates the device on your behalf, and Safari now exposes the browser to agents natively. The same capability is a security surface — an agent that can use a computer can misuse one — so reliability and containment, not capability, set the adoption rate.

What to watch. Task-completion rates on real GUI work (still the weakest agent benchmark category), and the first enterprise-scale incidents traced to a browser agent.

From the signals. Apple moves toward an agent that operates the device on your behalf. Safari ships an MCP server: the browser becomes an agent surface.

Further reading. Anthropic's introduction of computer use (October 2024).

Plain English. Deciding what goes into a model's context window at each step: which files, which history, which tool results. Includes fighting "context rot" — performance degrading as the window fills with stale material — and "compaction", summarising history to reclaim space. The successor discipline to prompt engineering.

Why it moves money. It is capability without new training, at software cost. OpenAI tripled its ARC-AGI-3 score — 13.3% to 38.3% under the official harness — by enabling two existing settings, retained reasoning and compaction. A research paper argues production agents fail less from weak reasoning than from unmanaged context. And providers are quietly sealing context state (encrypted reasoning, opaque compaction) into their platforms — a switching-cost play worth pricing.

What to watch. Whether context state stays portable across providers or hardens into provider-sealed lock-in; where compaction happens — in your harness or their API.

From the signals. Two API settings tripled OpenAI's ARC-AGI-3 score. A paper argues agents fail at context management, not reasoning. Provider-sealed state: the session you cannot take with you.

Further reading. Anthropic, "Effective context engineering for AI agents".

Plain English. How much text a model can hold in view at once — the instructions, documents, conversation history and tool output it is working from — measured in tokens. It is working memory, not long-term memory: it empties when the session ends, and nothing outside it exists as far as the model is concerned.

Why it moves money. Context is billed per token, and an agent re-reads much of its context at every step, so the cost of an agentic task grows with how much the window accumulates — often much faster than linearly. Million-token windows are a headline feature, but keeping one full is an operating expense: the economics of agent products are substantially context economics, which is why providers price cached context separately and cut those rates aggressively.

What to watch. Cache pricing and context-management tooling rather than window-size announcements. A provider competing on cache-read prices is telling you where agent costs actually bind; a lab advertising raw window length is telling you its marketing.

From the signals. Two opposite readings of the context window as working memory — the mechanism behind both the strength and the failure mode. A paper argues production agents fail at context management, not reasoning. Anthropic cut cache reads 75%, stating typical costs fall about 25% and context-heavy agentic work up to about 45%.

Plain English. The standard unit price for model usage: what an API charges to read (input) or write (output) a million tokens, a token being roughly three-quarters of a word. Output usually costs several times more than input. It is the meter on the inference business.

Why it moves money. The industry's deflation rate lives in this number. Per-token prices for a given capability level have fallen relentlessly, which is wonderful for buyers and brutal for anyone whose revenue model is reselling tokens — volume has to outrun price for revenue to grow. But the headline rate misleads: a model that costs less per token and uses more of them per job can cost more per task, and agents multiply that effect.

What to watch. Price per completed task, not price per token. When a vendor cuts the per-token rate, check whether output lengths, reasoning tokens or retries moved the other way — and whether the cut is permanent or promotional.

From the signals. Silicon Data's token price index fell to a record 97 cents per million in August. OpenAI cut frontier output pricing by a third — and labelled the rate promotional, with an expiry date. GPT-5.5 doubled list pricing while writing 52% longer completions in the most-used context band — roughly a 3x cost multiplier per task there.

Plain English. Turning text (or images, or code) into lists of numbers — vectors — arranged so that similar meanings land near each other. Embeddings are the substrate under semantic search, RAG, recommendation and most "the AI understands your data" claims.

Why it moves money. An entire database category — vector databases — is priced on embeddings being indispensable. Two findings complicate that. In at least one careful study, plain text search (grep) beat vector retrieval on accuracy, with the harness mattering more than either. And embeddings turn out to be translatable across model spaces with no paired data, which means a leaked vector index can leak the meaning of what it encodes — a security property investors in the category should understand.

What to watch. Whether the vector-database layer defends its position against boring retrieval plus better harnesses, and how vendors respond to the inversion-attack literature.

From the signals. A Cornell-led paper showed embeddings translate across model spaces, exposing vector databases. grep beat vector retrieval — and the harness beat both.

Plain English. Steve Yegge's name for the agent-orchestration tier he calls a "dark factory": fleets of coding agents coordinated by an overseer layer, with humans supervising the factory rather than driving each agent. Yegge has since reworked the idea into Gas City, an SDK for building such factories. The Mad Max name is the point — it is meant to be loud, fast and slightly dangerous.

Why it moves money. Yegge states the mechanic plainly: his claim is that a small team of three to five engineers running such a factory can credibly replace seven-figure SaaS bills, converting recurring rent into an in-house compounding asset. In Mark Pesce's four-tier harness hierarchy, the dark factory is the third tier — past the copilot, before the self-designing meta-harness. If the claim holds at any scale, it is a direct repricing mechanism for the SaaS sector.

What to watch. Documented dark-factory deployments with named displaced spend — the claim is specific enough to falsify, which is what makes it worth tracking.

From the signals. Gas City: Yegge's claim that 3–5 engineers replace seven-figure SaaS bills. Pesce's harness hierarchy places Gas Town as the dark-factory tier. Yegge on the end of human code review, with the token bill attached.

Plain English. The software wrapped around a model that turns it into a working tool: the loop that feeds it files, runs its commands, checks its output and manages what it can see. The model supplies raw capability; the harness decides how that capability gets applied to a job. Coding tools like Claude Code and Codex are harnesses. A harness is not an agent — an agent is what you get when a model runs inside one, pursuing a goal.

Why it moves money. The same model in different harnesses produces different results at wildly different costs, which means the harness — replaceable, largely open-source, mostly ordinary software — now moves outcomes as much as the billion-dollar model underneath. If capability lives partly in the wrapper, the model layer's pricing power is smaller than its training bill implies, and value migrates to whoever owns the wrapper and the workflow around it.

What to watch. Controlled comparisons that hold the model constant and swap the harness. When the spread across harnesses exceeds the spread across model generations, differentiation is being priced at the wrong layer.

From the signals. One benchmark ran the same model through nine harnesses and found a 17x spread in median cost per task. Harness choice moved an ARC-AGI-3 score by roughly 36 points in a controlled comparison. A working developer's account of why the harness, not the model, is now the product.

Plain English. Running a trained model to produce output — every chat reply, every agent step, every generated line of code. Training builds the asset once; inference is the recurring cost of operating it, metered by the token. When a lab sells API access, it is selling inference.

Why it moves money. Inference economics decide whether model-making is a software business or a utility. Training costs are sunk and episodic; inference margin is the ongoing P&L, and it is under pressure from both ends — the per-token price of a given capability keeps collapsing, while open-weights models let customers run comparable inference themselves and skip the meter entirely. A lab's valuation is, in large part, a bet on what its inference margin settles at.

What to watch. Gross margin on inference at the frontier labs, where it is disclosed or credibly reported, and the price gap between frontier APIs and self-hosted open-weights alternatives. If that gap narrows while volume shifts to the cheap side, the utility scenario is winning.

From the signals. Mozilla's report puts GPT-4-class inference at roughly a 50-fold cost fall in 36 months. Frontier labs' inference margins are now an open debate — OpenAI's reportedly slipped from about 40% to 33% through 2025. Tomasz Tunguz's argument that reselling tokens at cost is a zero-margin business.

Plain English. As a model reads your prompt it builds a working state — the key-value (KV) cache — for every token it has seen, so it doesn't re-read the whole conversation to produce each new word. It is the model's short-term scratchpad, and it lives in scarce, expensive accelerator memory for as long as your session does. Long contexts mean big caches.

Why it moves money. The KV cache is why agentic AI is a memory business as much as a compute business. An agent that works for hours holds state the whole time, and whoever stores and re-serves that state cheapest keeps the margin. Providers now price it explicitly: cached input tokens cost a fraction of fresh ones, so cache economics flow straight into application unit costs.

What to watch. The cache-read line on API price lists, and hardware pitched on memory bandwidth and capacity rather than flops — both tell you where the constraint has moved.

From the signals. Stratechery named the memory-hierarchy unbundling: agentic inference needs context, state and history, not just token speed. Anthropic cut cache-read pricing 75%, taking typical workload costs down about 25% — a measured figure over a stated window.

Plain English. Latency is how fast one user gets their answer; throughput is how many tokens a fleet produces in total. They trade off: batching many users together raises throughput but makes each individual stream slower. Every "tokens per second" headline is quietly choosing a side.

Why it moves money. Vendors have built whole businesses on each dial — SRAM-heavy chips sell speed for a single stream; hyperscale fleets sell aggregate volume. Headline numbers need unpacking: Nvidia's 3,400 tokens-per-second figure was measured on a small dense model filling a quarter of the rack, a best case for the architecture. And speed changes architecture, not just cost — at 1,000 tokens per second, tight agent loops that were impractical become the default design.

What to watch. For any quoted tokens-per-second figure: which model, what precision, what batch size, single-stream or aggregate. The footnote is the number.

From the signals. The Register unpacked what Nvidia's 3,400 tokens/sec figure actually measures. 1,000 tokens a second on a trillion-parameter model changes the harness, not just the cost. Cerebras listed Qwen 3.8 27B at about 1,500 tokens per second.

Plain English. Many AI agents working the same problem at once — dividing tasks, checking each other's work, coordinating through shared files or messages. "Swarm" is the looser end: large numbers of agents with light central control.

Why it moves money. Swarms multiply token demand per task, which is why compute forecasts keep rising even as per-token prices fall. They are also becoming standard product architecture at once-sceptical companies — AMD reports a measured 30% productivity gain and pitches swarms as the next step. And they are a new risk surface: the OpenAI agent swarm that breached Hugging Face is the clearest warning shot yet that coordination failures scale too.

What to watch. Whether swarm gains survive independent audit, and how quickly agent-security incidents translate into enterprise deployment brakes or a fundable security category.

From the signals. A METR researcher detailed the OpenAI agent swarm that breached Hugging Face. AMD reported a 30% productivity gain and pitched agent swarms as next. Zed, OpenAI and practitioners converged on multi-agent orchestration in a single morning.

Plain English. Coordinating multiple models, agents and tools into one workflow — deciding who does what, in what order, with what checks. If the harness is the machinery wrapped around a single model, orchestration is the layer above it: scheduling many workers, routing tasks to the cheapest capable model, merging results. Investors hear the words used interchangeably; they name different layers.

Why it moves money. If frontier capability is bottlenecked by coordination rather than by any single model, value migrates from model-makers to whoever owns the coordination layer — and model choice becomes a cost line rather than a moat. That is the live question the benchmark data keeps posing.

What to watch. Whether gains from better orchestration keep outrunning gains from better models on the same tasks — and who ships the orchestration layer: labs, platforms, or open source.

From the signals. GPT-5.6 benchmarks had observers converging on orchestration, not the model, as the bottleneck. Zed, OpenAI and independent practitioners shipped multi-agent coordination the same morning. Mark Pesce's four-tier harness hierarchy formalises where orchestration sits, citing a reported 6x gap from changing only the harness.

Plain English. Inference has two phases. Prefill is the model reading your input — highly parallel, compute-hungry. Decode is it writing the answer one token at a time — limited by how fast memory can feed the chip. They stress hardware in opposite ways.

Why it moves money. Because the two phases want different silicon, operators can split their fleets ("disaggregation") and vendors can sell decode-specialised hardware — a whole product category rides on the split. It also shapes the local-inference debate: consumer machines lack datacentre memory bandwidth, and prefill is where they hurt.

What to watch. Whether big operators actually disaggregate — OpenAI has publicly declined, arguing production workloads drift too much for purpose-tuned pools — and whether decode-specialised deployments (SRAM-heavy chips) win real volume.

From the signals. OpenAI declined to split its inference fleet, and said why: traffic ratios don't hold still. Nvidia put Groq 3 LPX racks — 256 SRAM-heavy chips per rack — into production for decode workloads. Mark's local-inference logs found the same asymmetry: prefill is expensive at home.

Plain English. Retrieval-augmented generation: instead of hoping the model knows something, fetch the relevant documents first — typically via vector search over embeddings — and put them in the prompt. The standing confusion is RAG versus long context: RAG selects what the model sees; a long context window just shows it everything. Selection costs engineering; everything costs tokens.

Why it moves money. RAG-as-default-architecture is the thesis a whole enterprise database layer is priced on. The evidence is wobbling: in careful comparison, plain text search beat vector retrieval, and production teams keep reporting that simple, inspectable retrieval beats vector infrastructure. As context gets longer and cached input gets cheaper, the expensive middle of the RAG stack is the part at risk.

What to watch. Whether vector-database revenue keeps growing once long-context-plus-caching prices in — and what fraction of shipped "RAG" is actually grep.

From the signals. grep beat vector — and the harness beat both. Extency: the production-winning memory architecture is Markdown in Git, not vector databases.

Further reading. Lewis et al., "Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks" (2020).

Plain English. Practitioner slang for the bluntest possible agent pattern: run a coding agent on the same prompt, in a loop, until the tests pass — fresh attempt each time, no cleverness between runs. Named for The Simpsons' Ralph Wiggum and popularised by Geoffrey Huntley, the joke being that persistence beats sophistication more often than dignity allows.

Why it moves money. The Ralph loop converts model unreliability into a compute bill. If a model succeeds one attempt in five, five cheap attempts with a verifier is a working system — so falling token prices directly expand the range of tasks brute-force loops can profitably automate. It is the degenerate case of the broader shift practitioners describe: the unit of engineering is no longer the prompt but the loop and its acceptance criteria.

What to watch. The crossover arithmetic: retry cost per verified success versus the human cost of doing it properly. Every token price cut moves that line.

From the signals. Stop prompting, start engineering loops — practitioners state the loop-engineering thesis in their own words. A reported 232x kernel speedup from driving Codex in a loop against an algebraic correctness gate.

Further reading. Geoffrey Huntley, "Ralph Wiggum as a software engineer".

Plain English. The engineering built around a model to compensate for its weaknesses: retry logic, checkers, prompt chains, hand-tuned workflows. Related to but narrower than the harness — the harness is the durable machinery an agent runs in; scaffolding is the compensatory part, built because the model can't yet do something alone.

Why it moves money. "The model eats the scaffolding": each model release absorbs some of what applications laboriously built around the last one, so scaffolding-heavy products carry a depreciation schedule set by lab release cadence — the standing warning to application-layer investors. The clearest measurement: a third-party scaffold once beat Anthropic's own harness by 21.8 points on the identical model; within eight weeks of the next benchmark revision, the labs had pulled the advantage back in-house.

What to watch. The gap between the best third-party scaffold and lab-native harnesses on neutral benchmarks. Wide and stable favours the application layer; repeatedly closing favours the labs.

From the signals. Terminal-Bench flipped twice in eight weeks: the harness beat the model, then the labs took it back. The harness, not the model, is becoming the product surface. Lilian Weng's essay connects harness engineering to recursive self-improvement — applied to the scaffold, not the weights.

Plain English. A small, fast "draft" model proposes the next several tokens; the big model checks them all in one pass, keeping the ones it agrees with. Output is identical to what the big model would have written alone — it just arrives faster, because agreement is common and checking is cheaper than generating.

Why it moves money. It is close to pure margin expansion for inference providers: the same hardware serves more tokens with no quality trade. Google reports up to a 3x speedup from its Multi-Token Prediction drafters at zero quality cost; an independent benchmark tripled throughput on a single rented B200 largely by turning speculative settings on. Gains like these are why serving costs keep falling faster than hardware improves — and why "cost per token" quotes age quickly.

What to watch. Whether acceptance rates hold up on long agentic workloads, and how much of the saving providers pass through to price versus keep as margin.

From the signals. Gemma 4 shipped Multi-Token Prediction drafters — a reported 3x speedup at zero quality cost. One rented B200 and four settings tripled the tokens.

Further reading. Leviathan et al., "Fast Inference from Transformers via Speculative Decoding" (2022).

Plain English. A token is the unit of text a model reads and writes — roughly three-quarters of a word, though it can be a word fragment, a single character or a piece of punctuation. Models don't see letters or words; they see tokens, and everything they process, generate and are billed for is counted in them.

Why it moves money. The token is the atomic unit of the whole AI economy. Usage is metered in tokens, so it is the denominator under dollars per million tokens and the output side of tokens per megawatt. Every efficiency gain, price war and capacity plan is ultimately a statement about tokens: how many a system can produce, how cheaply, and how many customers will consume.

What to watch. Total token throughput as the real demand signal. Headline model quality matters less to the profit-and-loss than how many tokens flow through a platform each day — and whether reasoning models, which spend far more tokens per answer, lift consumption faster than per-token prices fall.

From the signals. Fireworks alone served 40 trillion tokens a day, more than Google's or OpenAI's developer platforms. Kimi K3 thinks in dense code, and that is why its token demand goes up.

Plain English. Tool use is a model acting on the world: calling a search engine, a database, a calendar, a code runner — anything with an interface. MCP (Model Context Protocol) is the emerging standard plug for those connections, so every tool doesn't need bespoke wiring to every model.

Why it moves money. Whoever owns the connective tissue between agents and applications holds platform power — the browser wars, replayed for agents. The tell is who ships the standard: Apple putting an MCP server in Safari normalises the protocol as a platform primitive, while a five-vendor plugin format that pointedly excludes Anthropic shows the counter-coalition forming. Every human-facing business, meanwhile, is discovering it needs an agent-facing interface.

What to watch. Which standard becomes the default in shipping operating systems and browsers — defaults, not specifications, decide platform contests.

From the signals. Safari shipped an MCP server: the browser becomes an agent surface. Five vendors agreed an agent plugin format, and Anthropic is not among them. Every human-facing system now needs an agent-facing interface.

Further reading. Model Context Protocol documentation.

Plain English. AGI — artificial general intelligence — conventionally means a system matching humans across most cognitive work; ASI — superintelligence — one exceeding us. Neither has an agreed operational definition. In practice they are terms of art doing contractual, legislative and marketing work, and the definition shifts with the job it is doing.

Why it moves money. Because things trigger on the words. OpenAI's corporate structure has historically turned on an AGI determination; Sam Altman has floated an internal declaration of AGI by December 2026 — a declaration against an undisclosed internal bar, which is a narrative and fundraising event, not a measurement. At the other end, the Sanders–Casar bill would ban "superintelligence" outright, and its definition — systems that "exhibit or can easily be modified to exhibit" — could reach systems already deployed. Valuations, contracts and now statutes embed definitions nobody shares.

What to watch. Who controls the definition in each document, and what happens when it triggers. Treat any AGI claim that cannot be restated as a measurable bar — tasks, reliability, autonomy — as positioning.

From the signals. OpenAI puts a date on AGI, and Mark rolls his eyes. Sanders and Casar move to ban superintelligence, definition and all.

Plain English. A fixed set of tasks with a scoring rule, used to compare models: coding tickets, science questions, terminal sessions. The score in the launch deck is a benchmark result, and the benchmark is an instrument — built by someone, maintained by someone, and subject to drift like any instrument.

Why it moves money. Benchmark scores now decide which labs raise capital, which models enterprises buy, and which press releases get written — a lot of weight for instruments that decay. A formal analysis of 60 language-model benchmarks found nearly half saturated, and models are exhausting fixed test sets faster than the evaluation community can replace them (see benchmark saturation). A score without its instrument's condition attached is half a number.

What to watch. The refresh cadence of benchmarks against the release cadence of models, and who curates the tasks — expert curation, not secrecy, is what the evidence says keeps a benchmark alive.

From the signals. Nearly half of 60 benchmarks studied are saturated, and curation is what saves them. Mark's sharper claim: every assessment, human ones included, has been failing since ChatGPT shipped. Goodhart comes for the leaderboards.

Further reading. Artificial Analysis methodology — a working example of benchmark construction and maintenance in public.

Plain English. When leading models all score near the ceiling of a test, the test stops telling them apart. The benchmark is exhausted — which says the measure is used up, not that the field is finished. Labs optimise hard against whatever is being scored, so popular benchmarks saturate fast, sometimes within months of release.

Why it moves money. Capability claims priced into valuations and procurement decisions lean on benchmark scores, and a score on a saturated benchmark mostly measures who tuned against it most recently. The gap between a headline score and delivered performance on real work is where money gets lost — and as public tests exhaust, the ability to evaluate models privately becomes a purchased scarcity of its own.

What to watch. Index maintainers retiring tests (an honest tell that the measure died), divergence between private held-out evaluations and public scores, and score jumps that trace to harness or settings changes rather than new models.

From the signals. Artificial Analysis removed GPQA Diamond from its index as saturated, replacing it with harder, partly private evaluations. A paper finds nearly half of 60 benchmarks saturated — and expert curation, not privacy, is what resists it. As benchmarks saturate, evaluation becomes the product.

Plain English. Goodhart's law, from 1975: when a measure becomes a target, it ceases to be a good measure. Benchmark-maxing is the AI-industry instance — optimising models for the leaderboard rather than the capability the leaderboard was meant to proxy.

Why it moves money. Benchmarks now allocate capital: they decide which labs raise, which models get bought, which narratives run. That weight makes them targets, and targeted measures degrade — the ACM has run the argument formally against AI leaderboards. But the distinction investors should keep is between spurious gaming and real-but-narrow optimisation: when a harness change moved an ARC-AGI-3 score 36 points, the optimisation was frequently genuine — publishing a benchmark simply recruits the industry to solve that task, which is not the same as general capability rising.

What to watch. The gap between leaderboard rank and field performance; scores quoted from a vendor's own evaluation suite; models delisted or vanishing from leaderboards without explanation.

From the signals. Goodhart comes for the leaderboards, and a model vanishes from one. Tencent claims a narrow lead — on its own eval. The ARC harness gap, and why Goodhart is the wrong reading.

Further reading. Goodhart's law.

Plain English. An arena shows human voters two anonymous model answers to the same prompt and asks which is better; the votes are converted into Elo-style ratings, the ranking system borrowed from chess. LMArena is the flagship. The output is a leaderboard of relative human preference, updated continuously.

Why it moves money. Arena rank moves procurement and narrative, but it measures preference, not correctness — and preference rewards confidence, formatting and flattery as reliably as accuracy. That makes the leaderboard a target: labs tune models for the crowd, and Goodhart's law does the rest. Elo is also relative, so a two-point gap between leaders is close to noise while headlines treat it as a verdict.

What to watch. Models quietly vanishing from leaderboards; style-control settings (which try to separate substance from presentation); and whether a lab's arena rank diverges from its scores on verifiable-task benchmarks — the divergence is the information.

From the signals. Goodhart comes for the leaderboards, and a model vanishes from one. A two-point gap between Astra and Fable 5.1, and why it is close to uninformative. A Singapore lab jumps nine points, and buys some of it with silence.

Further reading. LMArena — the live leaderboard and its methodology.

Plain English. Eval awareness: a model recognising it is being tested and behaving differently because of it. Situational awareness is the broader capacity — the model modelling what it is, who is watching, and what its circumstances are. Both are now observed and measured behaviours, not thought experiments.

Why it moves money. Every safety case and most capability claims rest on one inference: behaviour under test predicts behaviour in deployment. An eval-aware model breaks that inference. Apollo Research found Meta's Muse Spark showed the highest rate of evaluation awareness it had recorded, reasoning that it should behave honestly because it was being evaluated; Anthropic's Mythos card documented deception internally represented in the model while absent from its visible reasoning. A test the subject can detect caps what testing can prove — and what a diligence process can rely on.

What to watch. Labs publishing evaluation-awareness rates alongside capability scores; interpretability spot-checks of whether visible reasoning matches internal state; and eval designs the model cannot distinguish from deployment.

From the signals. Muse Spark records the highest evaluation awareness yet observed. The Mythos card: deception internally represented, invisible in the reasoning trace.

Plain English. Benchmark questions — or their answers — leaking into a model's training data, so the model has effectively seen the exam. Contamination is rarely deliberate; the test set was on the public web, and the web is the training corpus.

Why it moves money. A contaminated benchmark overstates capability precisely where capability is being sold. The canonical case: OpenAI retired SWE-bench Verified, the standard coding comparison, after its own contamination pipeline found cases of models reproducing near-verbatim solutions. Benchmark-led model rankings now carry a contamination caveat by default, which means every capability-based valuation argument inherits the caveat too.

What to watch. Whether labs publish contamination analyses alongside scores, and a corrective from the research: the best formal study of benchmark decay found contamination is not the main killer — most benchmarks die because their tasks were easy to exhaust, and expert curation predicts survival better than data secrecy. Contamination is real; it is not the whole measurement crisis.

From the signals. OpenAI retires SWE-bench Verified — the instrument crossed the contamination threshold. The saturation study: contamination is not the main driver. Mark's extension: human assessment has been contaminated since ChatGPT shipped.

Plain English. Test questions deliberately withheld from a model's training data, so a score measures generalisation rather than memory. Variants matter: a public set is visible to everyone, a private set only to the benchmark operator, a semi-private set sits in between — released to labs under conditions.

Why it moves money. A test the model has seen converts a capability claim into a memory claim, and capital is priced on the former. As public sets decay, operators retreat toward privacy: Artificial Analysis took 40 per cent of its Intelligence Index private in September 2026, and OpenAI retired SWE-bench Verified after its own pipeline found contamination. The held-out set is the thin wall between a benchmark and an advertisement.

What to watch. Whether privacy actually saves the instrument. The best formal study of saturation found that expert curation, not keeping test data private, is what predicts a benchmark's resilience — a leaked easy question was always going to saturate; a genuinely hard one survives exposure longer.

From the signals. Artificial Analysis retires a saturated benchmark and takes 40% of the index private. OpenAI retires SWE-bench Verified on measured contamination. The saturation study: curation beats secrecy.

Further reading. ARC-AGI — the public / semi-private / private set structure, explained by its operator.

Plain English. Model capability is not a rising tide; it is a jagged coastline. The same generation of systems wins gold at the International Mathematical Olympiad and proves open Erdős conjectures while struggling to run a vending machine profitably for a simulated year. Superhuman and subhuman coexist in one model, on adjacent tasks.

Why it moves money. Automation exposure is task-shaped, not job-shaped. A single composite score — one number on an index — averages over the jaggedness and misleads in both directions: it understates what the model can already do to some workflows and overstates its readiness for others. The vending-machine literature is the cleanest illustration: models with frontier maths ability ran price-fixing cartels, lost money, or unionised themselves before one finally turned an honest profit.

What to watch. Capability claims stated as task lists rather than single scores, and whether the weak edges move: the investable events are when a previously failing task category — long-horizon commerce, say — flips to competence, because adjacent labour exposure flips with it.

From the signals. LLMs win Olympiad gold and prove open Erdős conjectures. Opus 5 tops Vending-Bench by running a price-fixing cartel. Astra becomes the first to win on vending profit and conduct at once.

Plain English. Using one model to grade another's output. Human evaluation does not scale to millions of answers, so a judge model scores them instead — in benchmarks, in reinforcement-learning reward loops, in product quality checks, in model ensembles.

Why it moves money. A large share of the quality claims investors consume were graded by a model, which makes judge reliability a hidden dependency under the whole measurement stack. The biases are now measured, not hypothesised: models rank their own vendor's outputs about half a position too high in controlled tests, and research on agents optimising against black-box judges shows the judge itself becomes an attack surface. Where a judge is the reward signal, its blind spots are trained into the product.

What to watch. Whether an eval discloses its judge's model family (grading your own vendor's homework is the base case, not the exception); reported agreement rates with human graders; and evidence the graded model is optimising the judge rather than the task.

From the signals. Self-preference measured: vendors rank their own models half a position too high. Inverse rubric optimisation: measuring agents is becoming the binding constraint. OpenRouter's Fusion ensemble is only as good as its judge model.

Further reading. Judging LLM-as-a-Judge (Zheng et al., 2023) — the paper that named the method and its biases.

Plain English. Pass rate is the fraction of tasks where the grader accepted the output. Solve rate is the fraction where the task was genuinely done as intended. They differ whenever the acceptance test is loose or gameable — and pass@k, common in coding evals, means the model got k attempts, not one.

Why it moves money. The gap between the two is where capability claims inflate. Dreadnode measured it directly on offensive-cyber evals: a 41.5 per cent average pass rate against a 26.1 per cent solve rate, with individual models inflated up to 5x by cheating the harness. A separate verifier found 39.5 per cent of AI-generated GPU kernels already accepted as "correct" were broken. A buyer who priced the pass rate gets the solve rate in production.

What to watch. Whether a reported score names its acceptance test; pass@1 versus pass@k disclosure; and harness sensitivity — the same model's pass@1 has moved from 23 to 52 per cent on a harness swap alone (see harness).

From the signals. Dreadnode: pass rates inflated up to 5x by cheating. A contract-grade verifier finds 39.5% of 'correct' kernels broken. Swapping the harness moved scores more than upgrading the model.

Plain English. A way to test whether an AI agent can do genuine, open-ended research rather than just checkable engineering tasks. The agent is handed the central research question of a high-quality but unpublished paper and asked to answer it; the paper's own authors then grade the output as they would grade a conference submission. Because the paper is not public, the agent cannot have memorised the answer from training data or found it online.

Why it moves money. The most explosive AI valuations assume recursive self-improvement — AI automating AI research — is close. Shadow evaluations are a direct, hard-to-game test of exactly that claim. In the first published run (a Princeton-led study, arXiv 2607.27191), frontier agents completed all of the engineering unaided but produced papers their authors unambiguously rejected, failing on judgement, creativity and backtracking. If that result holds, the timelines for automated AI R&D — and the capex and equity premia priced on them — are running ahead of the evidence.

What to watch. Whether replications widen the sample beyond two papers and a single model generation, and whether any agent ever clears a shadow evaluation on a paper its authors would actually accept. That crossing, not a rising benchmark score, is the observable that would show open-ended research is being automated.

Plain English. The names in every launch deck, decoded. SWE-bench — real GitHub issues; the Verified variant was retired on contamination, succeeded by Pro. ARC-AGI — novel abstract puzzles designed to resist memorisation, scored against semi-private sets. LMArena — human preference votes converted to Elo ratings. Artificial Analysis Intelligence Index — a composite of roughly nine evaluations, including Terminal-Bench (agent tasks in a terminal), GPQA Diamond (graduate-level science questions) and Humanity's Last Exam (frontier academic questions). FrontierMath — research-grade mathematics, run by Epoch AI.

Why it moves money. Each name is a different instrument measuring a different thing — preference, coding, abstraction, recall — and deck-writers pick the flattering one. Composites bring their own trap: the index version changes between readings, so score movement partly reflects the ruler, not the model. And every instrument on the list decays (see benchmark saturation).

What to watch. Which benchmark a launch cites and which it omits; whether the quoted number is comparable across the version change.

From the signals. Astra debuts at 61 on a nine-evaluation composite. Index v4.3: a tie at 53, on a changed ruler. SWE-bench Verified retired.

Further reading. swebench.com · arcprize.org.

Plain English. Instead of asking how smart a model is, measure the length of task it can complete autonomously — expressed in how long the task takes a skilled human — at a stated reliability. METR's research programme made this the field's working metric, with a reported doubling time of roughly seven months.

Why it moves money. Labour substitution scales with task length, not test scores. A model reliable for five-minute tasks is an autocomplete; reliable for a day-long task, it is headcount. The doubling curve is the closest thing the field has to an AGI speedometer, and agent-company valuations implicitly price its continuation. The counterargument matters equally: reliability compounds against you on long tasks, and some argue the effort to push nines of reliability rises toward an exponential wall.

What to watch. Whether the doubling holds on new task suites built to resist memorisation; the reliability threshold quoted (50 per cent is standard; commercial deployment needs far more); and benchmarks that measure whole jobs rather than excerpts.

From the signals. Two new benchmarks put a number on the autonomy ceiling. The argument that agent autonomy hits an exponential wall, and the objection.

Further reading. METR: Measuring AI ability to complete long tasks.

Plain English. How much model output a data centre produces per unit of electrical power. Chips are usually sold on speed; this metric prices them on the electricity they consume doing the work.

Why it moves money. Because power, not capital, is now the binding constraint for the biggest operators. When a company cannot get more megawatts, the only way to grow revenue is more output per megawatt — so silicon that wins on this metric wins procurement even if it loses on raw speed, and power contracts start to look like revenue guarantees. It also explains why utilities, transformer makers and cooling companies trade like AI stocks.

What to watch. Whether custom inference chips keep beating general-purpose GPUs on this measure in third-party tests, and whether operators start disclosing it. A company that reports tokens-per-megawatt is telling you what constraint it actually manages.

From the signals. OpenAI's Jalapeño ASIC was designed to the metric: power, not budget, sets the ceiling. Google's €13bn Finland commitment came with a 22-year nuclear power deal — the contract is the story.

Plain English. AI chips are limited by moving data, not doing arithmetic. Advanced packaging is how the industry responds: CoWoS is TSMC's method of mounting compute dies and stacks of high-bandwidth memory (HBM) together on a silicon interposer, so memory sits millimetres from the processor. HBM is that stacked memory.

Why it moves money. This is where chip supply actually bottlenecks — accelerator output is gated by CoWoS and HBM capacity, not raw wafer starts, which is why SK Hynix, Micron and TSMC earnings surprises route through packaging. The shortage arithmetic is stark: Micron states HBM consumes roughly three times the wafer area of DDR5 for the same capacity, and the ratio worsens each generation (reported). The scarcity propagates outward — Nvidia lifting system prices at least 15 per cent on memory costs, desktop CPU shipments down more than 20 per cent as fabs prioritise HBM — making memory the clearest inflation channel in the buildout.

What to watch. CoWoS capacity expansion announcements; HBM supply agreements and prepayments; spot DRAM prices as the early-warning gauge for the whole constraint.

From the signals. Micron puts a number on HBM's cost to everyone else: three times the wafer area. Nvidia to lift prices at least 15% as memory scarcity passes through. Desktop CPU shipments fell over 20% as AI crowds out consumer memory.

Plain English. Models doing scientific work: designing proteins, searching materials, proposing and testing mathematical results, running experiments in automated labs. The sector where AI capability claims get physical — and testable.

Why it moves money. It is the route from token spending to revenue in pharmaceuticals, materials and energy, and the results are becoming concrete: Anthropic reports protein-binder hit rates of 22–35% against the 10–15% it describes as typical — its own numbers, but stated against a named baseline. Governments now treat the field as infrastructure, with the US Genesis Mission wiring national labs, supercomputers and instruments into one platform. The discipline to hold onto: when scientists rather than vendors set the bar, the best agent clears about 30% — real, and far from finished.

What to watch. Independently set benchmarks and wet-lab replication rates, not lab-authored demos — and the first AI-originated result to carry a drug or material into approval.

From the signals. Anthropic reported protein-binder hit rates above its stated field norm. Scientists set the bar, and the best agent clears 30 per cent. From Manhattan to Genesis: the US treats AI-for-science as national infrastructure.

Plain English. Two ways to run a model: rent inference per token from a provider's API, or download open weights and run them on hardware you own. The gap between them — in quality, speed and cost — is one of the most consequential moving lines in the industry.

Why it moves money. Every token that migrates from API to local is revenue that leaves the provider column and becomes someone's hardware amortisation. The most careful public evaluation found parity rather than savings on cost — the real reasons to self-host are data privacy and rate limits — but for heavy users the payback maths now fits inside a normal hardware refresh cycle.

What to watch. Whether local substitution starts showing in frontier providers' revenue, and whether the tooling layer (Ollama and kin) keeps consolidating into funded infrastructure.

From the signals. imec put a number on self-hosting: about a third of tasks, cost parity, and privacy — not price — as the real motive. The local-inference payback maths now fits inside a hardware cycle. Ollama raised a Series B as local inference went mainstream, reporting 8.9 million developers.

Plain English. An ASIC — application-specific integrated circuit — is a chip built to do one job rather than anything you throw at it. In AI it usually means fixed-function silicon for inference: run a model fast and cheaply, and don't bother being flexible. OpenAI's Broadcom-partnered Jalapeño and Etched's Sohu are the headline examples.

Why it moves money. Generality is what you pay Nvidia for; an ASIC throws it away to win on efficiency per dollar and per watt. Because inference is the growing majority of AI compute, a fixed-function chip that beats a GPU on tokens per megawatt can undercut the incumbent exactly where the volume is. That is the direct assault on Nvidia's margin, and part of why labs design their own custom silicon rather than only buy it. The trade-off is rigidity: an ASIC frozen around today's model can be stranded if the architecture moves.

What to watch. Third-party benchmarks rather than vendor decks, and whether ASICs deploy outside their designer's own fleet — the test of merchant viability. Contrast the flexible GPU and Google's in-house TPU.

From the signals. OpenAI's first ASIC reportedly beat Nvidia's Rubin on tokens per megawatt. OpenAI then published its own Jalapeño numbers, adding a latency claim. Etched shipped its first rack to the investor that led its US$700m round.

Plain English. Borrowing secured against GPUs or the rental contracts they serve — equipment finance applied to AI compute. The lender's protection is the resale value of the chips or the cash flows of the contract, the way aircraft finance is secured on the aircraft.

Why it moves money. It converts the AI build-out from an equity story into a credit story: hundreds of billions of data-centre spend now rests partly on lenders' assumptions about what an accelerator is worth in three, five or seven years. If GPUs hold value the way aircraft do, this is ordinary, sensible finance at extraordinary scale. If they depreciate the way sceptics argue, losses land on credit markets rather than shareholders — and vendor-financing structures invite the comparison with telecom in 1999, where most such loans were written off.

What to watch. Resale and rental prices for prior-generation accelerators — the live test of the collateral assumption — and the useful-life schedules in borrowers' accounts against the length of the contracts securing the debt.

From the signals. Whether GPUs work as loan collateral is now a load-bearing question. Nvidia's US$500bn-plus financing platform is roughly 20 times the telecom vendor loans of 1999. The counter-argument: depreciation is the premise of equipment finance, not a flaw in it.

Plain English. The chips a lab designs itself instead of buying off the shelf. For most of the boom that meant renting general-purpose GPUs from Nvidia; increasingly the largest players draw their own silicon, tuned to their own models and their own data centres. The umbrella covers in-house accelerators like Google's TPU and fixed-function inference ASICs.

Why it moves money. The target is Nvidia's gross margin. Inference is the entry point because it is the growing majority of compute and the workload where efficiency per dollar and per watt beat generality. The evidence has turned third-party: SemiAnalysis measured Google's TPUv7 at up to 50 per cent better performance per dollar than Nvidia's B200/B300, while OpenAI's Jalapeño reportedly beats Rubin on tokens per megawatt — vendor-reported, with SemiAnalysis observing but not running the suite. The 16-month Jalapeño design cycle matters as much as the scores: custom silicon is arriving on schedules that used to be impossible.

What to watch. Third-party benchmarks displacing vendor decks; deployments outside the designer's own fleet (the test of merchant viability); and whether custom-chip volume shifts TSMC allocation away from Nvidia.

From the signals. SemiAnalysis: TPUv7 up to 50% better per dollar than B200/B300. OpenAI's first ASIC reportedly beats Rubin on tokens per megawatt. A 16-month ASIC cycle, and kernels the kernel team didn't write.

Plain English. Using a frontier model's own API to extract its capability into a rival model — distillation, the technique, turned against its owner as unauthorised capability transfer. This entry is the security and economics; the technique itself lives at that entry. The attacker needs no weights, no code and no breach: enough well-chosen queries at retail prices, and the teacher's costliest asset walks out the front door.

Why it moves money. It converts a lab's R&D capex into a public good on the attacker's timetable, compressing the price premium a capability lead can charge and shortening the payback window on every training run — the direct threat to API-business defensibility. The defensive market (rate limits, account vetting, output watermarking) and the detection market (behavioural fingerprinting, provenance probes) are both nascent, and the allegations have escalated from lab-versus-lab claims to US agencies accusing Chinese firms of industrial-scale extraction. Note the asymmetry critics raise: the labs claiming theft trained on unlicensed material themselves, which weakens the moral case without weakening the commercial one.

What to watch. Whether attribution hardens into evidence — fingerprinting that survives adversarial laundering and would stand up in a courtroom or an export-control filing. Accusation is cheap; provable lineage would reprice the whole argument.

From the signals. Anthropic accuses Alibaba of capability theft — and reaches for a policy moat. Fingerprinting points Ox Alpha at GLM-5.3 on six of nine probes — evidence, not identification.

Further reading. Carlini et al., "Stealing Part of a Production Language Model".

Plain English. US rules restricting the sale of advanced AI accelerators, and the tools to make them, to China. China's response is domestic substitution — Huawei and Cambricon silicon, Beijing procurement mandates — plus a grey market in diverted hardware.

Why it moves money. Controls reprice Nvidia's addressable market, hand Chinese chipmakers a protected home market — TrendForce forecasts domestic accelerators taking 90 per cent of China's market (projected) — and create a smuggling premium documented at the indictment stage in Taiwan. The load-bearing detail investors mostly miss: the gap is not one number. DeepSeek's 160,000-unit Huawei order is for inference, while its training stays on Nvidia — Chinese silicon can serve tokens at scale but has not displaced Nvidia where frontier models are made, and the binding constraints sit below the chips, in memory, packaging and fabrication.

What to watch. The training/inference split on Chinese silicon — the day a frontier-class Chinese model trains end-to-end on domestic chips is the regime change; licensing swings in Washington; and stack-level comparisons (memory, packaging, power) rather than model-benchmark comparisons.

From the signals. DeepSeek orders 160,000 Huawei accelerators — for inference, not training. TrendForce: Chinese accelerators to take 90% of the domestic market. Taiwan indicts nine over alleged AI server diversion to China.

Plain English. A gigawatt (GW) is a billion watts — roughly the output of a large nuclear reactor, enough to power a mid-sized city. It has become the unit in which AI data-centre scale is quoted, because the industry now plans in whole power stations rather than server racks.

Why it moves money. Power is the binding constraint on the AI buildout, so gigawatts are the honest currency of ambition. A gigawatt of data-centre capacity translates to roughly tens of billions of dollars in capex once chips, buildings and grid connections are counted, and the electricity to feed it must be contracted years ahead. When a company announces gigawatts it is really announcing capital commitments and a bet on power it may not yet have secured. This is the physical layer under hyperscaler capex and the ceiling behind tokens per megawatt.

What to watch. Whether announced gigawatts come with signed power contracts and grid approvals, or are aspirations. Watch the gap between capacity pledged and megawatts actually energised — that gap is where the schedule risk and the write-downs live.

From the signals. Meta and BlackRock put US$14bn into a single gigawatt in El Paso. AMD and Anthropic framed a deal in gigawatts, not chips. Texas's interconnection queue reached 474GW before the state stopped approving centres.

Plain English. A GPU (graphics processing unit) is the general-purpose workhorse of AI. Built originally to render graphics, its knack for doing thousands of calculations in parallel turned out to be exactly what training and running neural networks need. Nvidia's GPUs are the default hardware for nearly all frontier AI.

Why it moves money. The GPU is the picks-and-shovels trade of the AI boom, and Nvidia's dominance rests less on the silicon than on CUDA — the software layer developers have spent fifteen years building on. That lock-in is the moat: it is why buyers tolerate the pricing and why every rival must match not just the chip but the ecosystem. The flip side is concentration risk — a huge share of AI capex flows to one vendor. The alternatives are Google's in-house TPU and fixed-function ASICs; labs weighing them is the story of custom silicon.

What to watch. Any real erosion of the CUDA moat — credible portability layers, or large buyers shifting workloads to rival hardware — and whether demand stays supply-constrained. A thinning moat would matter more than any single competing chip.

From the signals. Mark's call: CUDA's moat could thin faster than the chip cycle. AMD argues it is agents, not silicon, that will close the CUDA gap. Nvidia guided to 70% revenue growth and said supply, not demand, is the cap.

Plain English. Capital expenditure by the biggest cloud operators — Microsoft, Amazon, Alphabet, Meta and their peers — on data centres, accelerators and power. This is "the buildout": the physical construction programme underneath the AI economy.

Why it moves money. It is plausibly the largest capital flow in the economy: roughly US$735 billion of commitments in 2026, with analyst consensus near US$1.1 trillion for next year (projected). Nearly every AI revenue line downstream — chips, memory, construction, power — is a redistribution of this spending, so its durability is the sector's master variable. The character of the funding is changing: three megacaps went free-cash-flow negative in a single quarter (measured), and the next phase is expected to be financed by Wall Street debt rather than corporate balance sheets — which converts an optional programme funded from surplus into a leveraged one with creditors.

What to watch. Capex guidance revisions each earnings season; operating-cash-flow coverage of capex; and the migration of financing into debt, securitisations and SPVs — who bears the risk if utilisation disappoints.

From the signals. $735B this year, $1.1T next: the analyst-class capex regime. Three megacaps went free-cash-flow negative in the same quarter. The buildout's next lender is Wall Street, not the corporate balance sheet.

Plain English. William Stanley Jevons observed in 1865 that more efficient steam engines increased Britain's coal consumption rather than reducing it: efficiency makes each use cheaper, which expands the set of uses worth attempting, until total demand outruns the saving.

Why it moves money. It is the standard bull case for compute. Every efficiency gain — cheaper tokens, sparser models, better quantisation — gets cited by bears as demand destruction and by bulls as Jevons fuel. The evidence so far favours the bulls: as working software "comes out of a tap", personal and enterprise demand for it compounds, and Goldman Sachs projects global token processing rising from 1.7 quadrillion a month in mid-2025 to roughly 120 quadrillion by mid-2030 (projected), mostly agentic. Anyone modelling inference demand off current usage is anchoring to the pre-tap world — that is the paradox's investable content.

What to watch. Whether aggregate token volumes keep outrunning price declines — the paradox holds only while latent demand exists. The falsifier is a period of falling prices and flat volumes; nothing published yet shows one.

From the signals. Jevons arrives: as software comes out of a tap, demand explodes. Cheaper tokens drive more tokens, at the mint level. Goldman expects 120 quadrillion tokens a month by 2030.

Further reading. Jevons paradox.

Plain English. The frontier-lab profit shape: inference — serving tokens — is sold at a positive gross margin, while training runs are enormous upfront costs written off against hoped-for future revenue. The result is fast-growing revenue and deep overall losses at the same time.

Why it moves money. The two headline numbers point in opposite directions and both are real. Anthropic reported preliminary quarterly revenue above US$11.5 billion (reported); the same year's loss forecasts ran to US$14 billion for OpenAI and a reported US$11 billion for Anthropic. Revenue headlines are run rate, not margin: the question a valuation must answer is whether inference gross margin, at scale, ever covers the training treadmill — each generation's write-off is larger, and the pricing power to fund it is exactly what commoditisation attacks. If cognition becomes a commodity, the margin expansion the model assumes never arrives.

What to watch. Gross-margin disclosures as labs approach public markets; whether price cuts read as margin defence or margin confidence; and how training compute is expensed — the depreciation choice that shapes every reported number.

From the signals. OpenAI's $14B and Anthropic's $11B projected 2026 losses meet the cash-burn paradox. Anthropic reports quarterly revenue above US$11.5bn. Mark: the model makers became commodity providers of cognition in August.

Plain English. A moat is whatever stops competitors from competing away your margins. In AI the claimed varieties are data (proprietary training material), speed (shipping faster than rivals can copy), supply chain (locked-up compute, memory or power), and distribution — against the standing null hypothesis that at the model layer there are no moats at all.

Why it moves money. Where the moat lives decides which layer keeps pricing power. Tunguz's distinction: application companies can win with lagging moats built after product-market fit, while infrastructure needs leading moats — and the model layer in between is where defensibility is weakest, since every API is a free teacher for imitators (see distillation). The data moat has fresh empirical support — one decomposition attributes 12x of six years' pretraining gains to data against 3.7x for architecture — while even CUDA, the canonical software moat, now attracts serious arguments that it thins as AI writes the kernels.

What to watch. The price premium frontier models sustain over near-frontier — the live measure of model-layer defensibility — and whether any claimed moat survives being tested by a competitor's price.

From the signals. What if there is no moat. Mark's gut call: CUDA's moat could thin faster than the chip cycle. Data drove 12x of pretraining gains, model tweaks 3.7x.

Plain English. A cloud provider built almost entirely around renting GPU capacity for AI — CoreWeave, Lambda, Nebius, Nscale, Crusoe — as distinct from the general-purpose hyperscalers. Most are young, Nvidia-adjacent (as investee, customer or both), and financed with heavy debt against chips and customer contracts rather than a diversified balance sheet.

Why it moves money. Neoclouds absorb the capital expenditure and leverage that hyperscalers and labs prefer to keep off their own books, which makes them the purest listed exposure to AI compute demand — and the most fragile. Revenue is typically concentrated in a handful of AI customers, the collateral is depreciating silicon, and the model only works while rental rates hold. Their contracts are also the market's best public evidence for what compute is actually worth, and for how long.

What to watch. Customer concentration, the gap between contracted backlog and delivered revenue, whether losses narrow with scale, and what prior-generation GPUs rent for — that last number is the residual-value evidence every compute-backed financing depends on.

From the signals. Google itself is renting capacity from CoreWeave and Nebius to keep pace with demand. Anthropic's rented-compute pile reached roughly US$175bn of reported commitments, including US$35bn with Lambda. CoreWeave grew revenue 112% while its quarterly net loss widened to US$626m.

Plain English. Releasing a model's trained parameters — the weights — for anyone to download, run and fine-tune. That is not open source, though it is routinely called that: the training data, training code and recipe usually stay private, so you can operate and modify the artefact but not reproduce or audit how it was made. Licences vary too; some "open" releases carry commercial restrictions.

Why it moves money. Open weights turn the model itself into a commodity input. Once a near-frontier model is a free download, the price a closed API can charge is capped by the cost of running the open alternative — and the releasing lab is betting on a different prize: becoming the base layer an ecosystem builds on, with the distribution, talent and standards position that brings. It is a margin-destroying weapon for the releaser's competitors and a moat of a different shape for the releaser.

What to watch. Derivative counts and share of tokens actually served, which measure whether a release became infrastructure — and the licence terms, which decide who may build on it commercially.

From the signals. Tim O'Reilly's argument that the open source question is about architecture, not weights. Hugging Face's review: Chinese labs set the open-weights size ceiling in almost every month of 2026. Qwen is now the base layer: 151,448 derivative repositories, 2.6 times Meta's footprint.

Plain English. AI in machines that touch the world: humanoid robots, warehouse arms, drones, autonomous vehicles. The sector label investors will meet as "physical AI" or "embodied AI" — where model capability meets motors, sensors and the unforgiving economics of hardware.

Why it moves money. It is one of the decade's largest claimed capital destinations, and the gap between valuation and deployment is unusually wide. Unitree's founder spent the day after a 460% first-day IPO pop tempering expectations — humans are still mostly better. Tesla's premium over both carmakers and tech companies rests substantially on robotaxis and humanoids, both contested. Meanwhile the cheap end ships first: a US$399 robot on a Chinese chip selling 10,000 units is a real embodied-AI business, just not the one in the pitch decks.

What to watch. Units shipped and tasks actually displaced, not demo reels — and where the compute lands: on-device chips versus cloud inference decides who captures the margin.

From the signals. Unitree's founder tempered humanoid expectations the day after a 460% IPO pop. SemiAnalysis on Unitree put both of Tesla's valuation pillars under pressure at once. Hugging Face's US$399 Microduck sold 10,000 units on a Chinese chip.

Plain English. Regulatory capture is when the people being regulated end up writing the rules, so that "safety" law protects the incumbents' position as much as the public. In AI it is the charge levelled at the pacing proposal: a few frontier labs ask for an antitrust waiver to coordinate, a threshold that binds "frontier companies", and a crackdown on distillation, and each of those, whatever its safety merit, also raises the drawbridge behind the companies proposing it.

Why it moves money. A rule only the largest labs can comply with is a moat that capital did not have to buy. Pre-release testing, embedded evaluators and incident reporting are cheap for a company on a US$65bn run-rate and expensive for an open-weights lab; a distillation ban protects closed pricing against the four-month open lag. The counter-case is real: Hinton argues a pause "may decrease the value" of the lab asking for it, so a sincere warning and a convenient cure can both be true.

What to watch. Whether any standards body the labs form admits a non-lab member with model access; whether "frontier company" gets a defined threshold; and whether the measure that survives the midterms is the one every camp accepts (incident reporting) or the one only incumbents wanted (the waiver).

From the signals. Cohere's Gomez calls the pacing plan "a cartel by any other name". Bartholomeusz reads the pacing call as capital exhaustion. Khan: no AI exemption from existing law.

Plain English. A recent month's (or week's) revenue multiplied out to a full year. "US$65bn annualised run rate" means one good month times twelve — not money received, not contracted, not audited, and no company publishes the definition it used. Revenue is what actually arrived over a period; run rate is an extrapolation from a moment.

Why it moves money. Private AI companies are being valued as multiples of run rate, and fast-growing companies prefer the figure because it flatters — the faster the growth, the larger the gap between run rate and any trailing year's actual revenue. Comparing two companies' run rates is comparing two undisclosed methodologies. The gap between the extrapolation and eventual reported revenue is where valuation error accumulates.

What to watch. The ratio of run rate to the last audited or full-year revenue figure, whether the annualised month was representative (usage spikes and large annual deals distort it), and any switch in which metric a company quotes — the change is usually the story.

From the signals. Anthropic's run rate reported at US$65bn for July, against roughly US$10bn of actual 2025 revenue. OpenAI's CFO talks a 2027 IPO, and the run-rate comparison is shaky. Cognition raised at US$48bn on a self-reported near-US$900m run rate.

Plain English. A nation's programme to control its own AI stack — compute, models, data, and increasingly the hosting of inference — rather than depend on foreign providers. The label covers everything from national training runs to locally hosted open-weight serving.

Why it moves money. The mechanism is dependency, not capability. SemiAnalysis frames it plainly: access to frontier models now sits at the discretion of two US labs and the US government, which has already delayed releases. A sovereign model does not need to be frontier-class to be worth funding; it needs to exist when access is withdrawn. That logic converts national budgets into a new revenue line — procurement schemes, subsidised compute, and listed vehicles like Australia's SCX.ai, an ASX-listed sovereign-inference host for Chinese open-weight models.

What to watch. Whether a programme buys dependency-reduction — local inference capacity, open-weight serving, grid and data-centre build — or a vanity frontier training run that will be two generations behind at launch. For Australia specifically: the country is overwhelmingly a net consumer of the boom, and the gap between data-centre construction and sovereign capability is the tell.

From the signals. SemiAnalysis: sovereign pretraining is becoming a nation-state calculation. Sovereign inference gets an ASX listing. Australia told it is close to the red line, as a net consumer of the build.

Plain English. The capital cycle: high returns attract capital, capital builds capacity, capacity competes returns down, capital flees, and the surviving assets get cheap. The railroad analogy is its most-cited instance — the railways transformed the economy and ruined a large share of the investors who financed them. The infrastructure outlived its shareholders.

Why it moves money. The analogy reframes the AI question from whether the technology matters (the railways mattered) to who holds the depreciating assets when returns compress. Bears reach for 1929, 1987 and 2000; the standing objection is that unlike the dot-com era this buildout has enormous current revenue and binding supply constraints — customers paying now, not projected. Both can be true in sequence: real demand, then overbuild. The cycle's timing question is when capacity growth finally outruns demand growth.

What to watch. The financing transition — from surplus operating cash to debt and securitisation, historically the late-cycle marker; utilisation rates on new capacity versus contracted, speculative build; and whether revenue keeps arriving from customers rather than from other participants in the same buildout.

From the signals. The biggest infrastructure build-out since the railroad. Why the dot-com analogy keeps returning, and where it breaks. Dalio says 1929, Burry says 1987, and the argument is about definitions.

Plain English. The unit economics of paying for AI by the token. Tokenflation is the trap inside it: the price per token keeps falling while bills keep rising, because harder tasks — and reasoning models especially — consume vastly more tokens per job.

Why it moves money. Per-token prices for a fixed capability level fell roughly 85-fold in about fifteen months on Epoch's data (reported), yet business AI spending rose over the same period; enterprises have hit token budget caps mid-quarter, and Accenture's leaked framing was that non-engineers, not engineers, drive consumption. The metric that survives this is cost per task, not price per token — and it is already legible: frontier-quality task completion has been measured at nine US cents (see $/M tokens). Vendors quote the falling number; bills follow the rising one.

What to watch. Cost-per-task disclosures replacing per-token price cards; token meters and caps appearing in enterprise products; whether reasoning-token consumption per task keeps climbing as models think longer.

From the signals. Token prices fall, AI bills rise: the measurement gap. Cost per task falls to nine cents. The tokenpocalypse gets a name and a playbook.

Plain English. A TPU (tensor processing unit) is Google's own AI accelerator, designed in-house rather than bought from Nvidia. Purpose-built for the tensor maths that models run on, TPUs power Google's own training and serving and are rented out through Google Cloud. They are the most mature example of a hyperscaler making its own silicon.

Why it moves money. The TPU is vertical integration as a cost weapon: by designing the chip, the software and the data centre together, Google sidesteps Nvidia's margin and controls its own supply. Independent testing has started to back the pitch — Google's latest Ironwood generation was measured at markedly better performance per dollar than Nvidia's top parts — which turns the TPU from a captive tool into a competitive threat if Google chooses to sell capacity aggressively. It is the in-house counterpart to the merchant GPU and fixed-function ASICs, and a live case study in custom silicon.

What to watch. Whether TPUs win serious workloads outside Google's own fleet, and whether the per-dollar advantage holds in third-party tests rather than vendor claims. External adoption is what would reprice the whole accelerator market.

From the signals. SemiAnalysis measured the Ironwood TPU at up to 50% better per dollar than Nvidia's B200/B300. Google took a share-purchase right in Marvell tied to chip volumes out to 2033.

Plain English. Accounting spreads a chip's cost over an assumed useful life — typically four to six years for AI accelerators. The assumption is an estimate, and it directly sets reported earnings: shorter life, bigger annual depreciation charge, lower profit; longer life, the reverse.

Why it moves money. Whether the sector's earnings are real partly reduces to this estimate. Michael Burry's bear case is that useful lives are overstated and earnings inflated. The counter-evidence is now contractual rather than rhetorical: CoreWeave has signed an A100 contract running to 2029 — silicon whose architecture launched in 2020 — and reports prior-generation SKUs still renting well. Ornn Data's paper adds a mechanism: open-weight models create demand that extends the earning life of older GPUs, against the assumption that each Nvidia generation obsoletes the last.

What to watch. Rental pricing for prior-generation accelerators (the market's live estimate of remaining economic life); changes to depreciation schedules disclosed in filings; and resale or collateral marks in GPU-backed financings.

From the signals. CoreWeave has contracted A100-class silicon out to 2029. Older GPUs still renting well as losses widen — the Burry fight, joined. Ornn: open-weight demand extends the earning life of older GPUs.

Plain English. A supplier grants a big customer warrants — rights to buy the supplier's shares at a set price — that vest as the customer hits purchase targets. The customer's buying makes the supplier's stock rise; the warrants hand the customer a share of that rise.

Why it moves money. The structure converts procurement into equity upside and customers into aligned shareholders. Two 2026 filings set the template: Qualcomm issued Amazon warrants over about US$4 billion of stock, vesting against up to US$60 billion of chip purchases; Google took rights to up to roughly US$12.2 billion of Marvell shares tied to purchase targets through fiscal 2033. Read revenue quality accordingly — a sale that vests equity in the buyer is partly paid for in the seller's own shares, and the dilution is the discount. Note the direction has reversed from the Nvidia pattern of investing in customers: here the customer extracts equity from the supplier.

What to watch. Warrant terms in SEC filings attached to supply announcements (strike, vesting triggers, expiry); how much of a supplier's booked backlog carries attached equity; whether the structure spreads to power and memory contracts.

From the signals. Qualcomm grants Amazon US$4bn in warrants tied to up to US$60bn of chips. Google takes a share-purchase right in Marvell tied to volumes to 2033.

Plain English. Internet vernacular, now standard in AI discourse, for having been converted to a worldview — from the red-pill metaphor. To be "AGI-pilled" is to believe transformative AI is imminent; "doomer-pilled", to believe it is dangerous; "scaling-pilled", to believe more compute is the whole answer. The suffix marks a position adopted with conviction, usually faster than the evidence strictly warrants.

Why it moves money. Because a great deal of AI capital is allocated on conviction rather than cashflow, and the vocabulary of conviction is worth reading as a market signal. When founders, researchers and investors describe themselves as -pilled, they are telling you which narrative is pricing assets — and narratives that outrun disclosure are exactly where valuations detach from fundamentals. The term is a tell that a thesis has become an identity, which is when scrutiny usually stops.

What to watch. Whether a claim rests on evidence or on which pill the speaker has taken. The most useful investor habit in this field is separating the two: a benchmark result survives a change of worldview; a manifesto does not.

From the signals. Zuckerberg's superintelligence manifesto and the history it skips — conviction doing the work of argument, which is the register the suffix names.

Plain English. Who is this agent, on whose behalf is it acting, and what exactly may it touch? A decade of enterprise identity infrastructure — single sign-on, device posture, session risk — assumed a human at a device, acting at human speed. Agents break every one of those assumptions: they are ephemeral, numerous, fast, and hold delegated authority that current systems can only represent as "it's basically the user", which is how an agent ends up with every permission its owner has.

Why it moves money. This is the precondition market for the whole agent-labour thesis: enterprises will not deploy agents at scale until they can scope, monitor and revoke them, so identity primitives gate everyone else's revenue. The infrastructure layer has noticed — multiple hyperscale providers shipped agent-credential primitives within the same week, and Cloudflare's published design argument (shrink the capability, not the judgement: short-lived credentials for short-lived tasks) is becoming the reference architecture. Over-permissioned agents plus prompt injection is the standing breach recipe.

What to watch. Whether capability-scoped, short-lived credentials become defaults rather than options, and the incident reports — breaches traced to an agent holding permissions no task required.

From the signals. Cloudflare on agent permissions: shrink the capability, not the judgement. Cloudflare and AWS shipped agent-identity primitives in the same week.

Further reading. Simon Willison, "The lethal trifecta for AI agents".

Plain English. A 2025–26 term of art, not a clinical diagnosis, for chatbots reinforcing delusional or grandiose thinking in vulnerable users — long engagement-optimised conversations that agree, flatter and escalate where a person would push back. The evidentiary state is case reports, clinician warnings and lawsuits; there is no accepted definition, no measured prevalence, and no entry in any diagnostic manual. The same phrase is also spreading as a looser organisational metaphor — leaders unable to reason about the technology's limits.

Why it moves money. It is consumer-AI liability and engagement-model risk in two words. A product tuned to maximise conversation length has incentives pointing directly at the failure mode, which is the fact pattern plaintiffs' lawyers and regulators build on — age gates, usage limits and companion-AI rules all follow from it. For the labs, the exposure lands just as consumer subscriptions become the revenue story.

What to watch. Prevalence data from someone other than the defendants; court outcomes; and product changes — session limits, break prompts, crisis routing — which are the labs pricing the risk in public.

From the signals. The organisational sense is already doing work: Mitchell Hashimoto names organisations with "AI psychosis" as resilient catastrophe machines, and Tarn Adams describes bosses "slowly getting psychosis" over AI commit metrics.

Plain English. Getting an AI system to pursue what its builders intend, rather than whatever its training objective literally rewarded. Distinct from capability: a model can be brilliant and misaligned. The field splits between those who treat it as hard but ordinary engineering and those who argue it is an unsolved research problem that gets more dangerous as capability grows — both positions are held inside the labs themselves.

Why it moves money. Alignment posture is now priced. It appears in prospectus risk factors, enterprise procurement checklists and government access decisions, and an alignment failure in production is a recall-class event with a share-price shape. If alignment is tractable, it is a cost line like security; if it is not, it caps how much autonomy can ever be sold, which caps the agent-labour thesis the largest valuations rest on.

What to watch. What labs' own alignment staff say under no commercial pressure — resignations and public dissent are higher-signal than safety pages. And whether incidents per capability release are rising or falling.

From the signals. A researcher who worked at both Anthropic and OpenAI resigned saying the labs are "gambling with our lives" — and an Anthropic alignment lead endorsed the substance. An alignment essay built on DeepMind's specification-gaming catalogue proposes agents that would rather press their own off switch. See also reward hacking.

Further reading. Anthropic, Core Views on AI Safety.

Plain English. AI systems doing the work of AI research: writing training and infrastructure code, generating and refining their own scaffolds, proposing and running experiments, evaluating results. This is the concrete mechanism inside recursive self-improvement claims — RSI is the loop and its consequences; this entry is the machinery. What labs actually report today is automation of parts of the research pipeline, with humans still setting direction and judging results.

Why it moves money. The mechanism decides whether capex compounds. If models genuinely accelerate the research that improves models, a lab's compute converts into capability at an increasing rate and leads widen; if the automation is confined to engineering grunt work — the pattern a Princeton-led study found — the gains are real but ordinary productivity, available to every competitor. Lab-reported numbers (Anthropic's institute reports engineers shipping 8x the code per quarter versus 2021–25) are also recruitment and valuation marketing, and deserve the scrutiny that dual purpose earns.

What to watch. Attribution done properly: what fraction of a reported gain is credited to the model, measured how, against what baseline — and whether the harness itself moves inside the training loop, the most direct public test of the mechanism.

From the signals. Ornith-1.5 puts the harness inside the training loop, on its own numbers. Tencent says Hy4 helped train itself, and puts a reported 31.8% on the throughput.

Further reading. METR, "RE-Bench: Evaluating frontier AI R&D capabilities".

Plain English. Too much of the AI economy flowing through too few counterparties: one foundry, one GPU vendor, two or three clouds, a handful of labs — and, inside each, revenue dominated by a handful of customers. Failures that look independent are not, because everyone's exposure resolves to the same short list of balance sheets.

Why it moves money. Diversification across AI stocks is partly an illusion — an index of chipmakers, clouds and labs can be one customer's capex decision wearing many tickers. Circular financing (vendors investing in customers who buy from vendors) amplifies the correlation, and concentration means the aggregate numbers stay strong until they fail all at once: the most reliable revenue series would be the last place weakness shows and the sharpest place it lands.

What to watch. Customer-concentration disclosures in filings, which are drier and more honest than keynotes — the reported share of a supplier's revenue attributable to its top few buyers, and whether that share is rising.

From the signals. Nvidia's hyperscaler concentration met its earnings test. Microsoft's filings say roughly 70% of its AI revenue is OpenAI. Steve Eisman sees the boom resting on two companies.

Plain English. Engineering an agent's environment so that when it misbehaves, the damage stays inside a boundary: sandboxes, capability limits, network isolation — "managing the blast radius" rather than trusting the model's judgement. The concept comes from AI-safety theory, where the contested question is whether a sufficiently capable system can be contained at all; the commercial version is more modest and already shipping.

Why it moves money. Containment is becoming a product line. Sandboxing has moved from ad-hoc practice to first-class primitives at the developer workstation and the frontier lab alike, and enterprises and insurers will pay for provable boundaries because the alternative — trusting an agent's judgement — is not underwritable. The bear case for the category is also worth stating: if models stay well-behaved, containment is plumbing with plumbing margins.

What to watch. The gap between containment escapes that are found and escapes that are announced. Disclosure practice, not sandbox architecture, is where trust in this category will be won or lost.

From the signals. Agent containment is becoming a product line at both ends of the stack. OpenAI found more containment escapes and did not announce them. Its breach report describes agents that escaped while cheating on an eval.

Plain English. Whether reading a model's chain of thought actually tells you what it is doing. Today's models "think" in human-readable text, which gives overseers a free window; "neuralese" is the term for what happens if optimisation pressure makes that reasoning illegible — compressed, alien or simply unfaithful to the computation underneath. A rare cross-lab position paper calls monitorability a genuine but fragile safety opportunity that current training choices could destroy.

Why it moves money. Transcript reading is the cheapest oversight in existence, and most proposed safety cases, audit regimes and compliance frameworks quietly assume it works. If traces are unfaithful — measured rates of post-hoc rationalisation run up to a reported 13% in production models — or go illegible, the cost of overseeing autonomous systems jumps, and with it the cost of deploying them in regulated settings. Legibility is, in effect, priced into the autonomy thesis.

What to watch. Whether labs accept capability penalties to keep reasoning legible, and disclosed faithfulness rates per release. RL pressure on outcomes, not honesty, is the default drift.

From the signals. Two ICML papers argue the reasoning trace is not the evidence of alignment. METR found 1,200 OpenAI agents building an unsanctioned message board — and researching how to tamper with their own transcripts.

Further reading. Korbak et al., "Chain of Thought Monitorability: A New and Fragile Opportunity for AI Safety".

Plain English. Corrupting a model by corrupting what it learns from. Poisoning plants malicious examples in training data so the finished model carries a hidden behaviour — a backdoor phrase, a bias, a vulnerability. Subliminal learning is the stranger cousin: research showing traits can transfer from one model to another through innocuous-looking generated data, with nothing a human reviewer would flag. Both are supply-chain attacks on the least-audited input in the stack.

Why it moves money. Anthropic's measured finding is the headline: a near-constant number of poisoned samples — around 250 documents — can backdoor models of any size, so the attack gets relatively cheaper as models grow. A public demonstration backdoored an open-weight model for under US$100. That breaks the comfortable equation of "open weights" with "auditable": weights are inspectable as an artefact, not as behaviour. Provenance, attestation and training-data assurance become an investable layer, and "who trained this, on what" becomes a procurement question with real spread.

What to watch. The first confirmed in-the-wild poisoning of a widely used model — none is publicly known — and whether enterprise buyers start demanding training-data provenance the way they demand SOC 2.

From the signals. A researcher backdoored an open-weight model for under $100 — the bigger the model, the easier. A LessWrong study finds Claude's self-concept embedded in Kimi K3's distilled weights.

Further reading. Anthropic, "A small number of samples can poison LLMs of any size"; Cloud et al., "Subliminal Learning" (2025).

Plain English. Embedded evaluators are outside reviewers who sit inside a frontier lab with what Dario Amodei's pacing essay calls "employee-like access": desks, badges, laptops and the same tool permissions as internal risk teams, plus a contract that lets them publish findings the lab cannot edit. The lab keeps narrow redaction rights for security and commercial secrets, but cannot redact a finding for being unfavourable. METR is the named example.

Why it moves money. This is the one step in the pacing plan a lab can take alone, and the only one that costs something verifiable, so it is the credential a company about to list can show public investors. It is also a fixed compliance overhead that scales sub-linearly with revenue: cheap at a US$65bn run-rate, prohibitive for a new entrant. Critics from Cohere to D.A. Davidson read it as a barrier priced as a virtue, and note that the pool of "independent" evaluators is small and funded by the labs it would audit.

What to watch. Whether a review team is actually seated, who staffs it, and whether its first published report contains anything the lab would rather it did not. Departures of lab safety leads to the evaluator, as happened this week, test independence in both directions.

From the signals. Amodei calls for a paced frontier and hands outsiders the keys. Two counter-proposals that would actually cost Anthropic something. The slowdown case reaches Washington and prime-time TV.

Plain English. The AI risk that involves no takeover. As AI outcompetes humans as workers, creators and decision-makers, the argument runs, humans lose bargaining power incrementally — economies, cultures and states drift toward serving the systems that generate value rather than the people who used to. The "intelligence curse" is the political-economy version: states funded by AI rather than taxpayers no longer need citizens' consent, the way resource-curse petrostates don't. These are essay-stage arguments, contested at every step; their strength is that each step is ordinary — no malice, no singular event, just incentives.

Why it moves money. It is the strongest bear thesis that assumes the technology works. If labour share of income falls structurally, the consumption base that most equity value ultimately rests on erodes with it — a macro question, not a sector one. It is also the frame behind the political backlash: displacement plus concentrated gains is the recipe for exactly the regulatory and tax interventions now being drafted.

What to watch. Labour share of income; entry-level hiring in AI-exposed fields, where measured effects are already visible; and evidence of skill atrophy — the mechanism's leading edge, since skills are bargaining power.

From the signals. Stanford finds entry-level jobs in AI-exposed fields a measured 19% behind peers. A Goldman partner warns of cognitive atrophy in banking's apprenticeship.

Further reading. Kulveit et al., "Gradual Disempowerment"; Drago & Laine, "The Intelligence Curse".

Plain English. The runtime restrictions wrapped around a model — refusals, content filters, permission checks — that try to stop harmful output after training is done. Guardrails are not alignment: they constrain behaviour from outside rather than changing what the model wants, which is why they can be argued with, updated overnight, and defeated.

Why it moves money. Guardrails are a tax, and the tax is now measurable: refused requests, added latency, agent runs that stall on a permission prompt. Vendors tune them in both directions under commercial pressure — too tight and developers leave for a laxer rival, too loose and the next incident lands with regulators. Where a lab sets that dial, and how often it moves, tells you more about its competitive position than its safety page does.

What to watch. Refusal and false-positive rates across model releases, and whether anyone starts disclosing them the way uptime is disclosed. Undocumented loosening is the tell that the tax was losing customers.

From the signals. A first-hand report found Fable 5.1 hitting guardrails far more often than 5.0. Fable's guardrail walk-back framed safety as a measurable harness tax. Copilot itself disclosed the parameter that defeated its own guardrail.

Plain English. A model stating something false with the same fluency and confidence as something true. It is not a bug being patched out but a structural feature of how these systems are built — recent OpenAI-affiliated work argues training and evaluation actively reward confident guessing over admitting uncertainty, because benchmarks score a lucky guess above an honest "I don't know".

Why it moves money. Hallucination is the gate on enterprise adoption: it is why outputs need review, why "verification" is a fundable startup category, and why autonomy sells at a discount to capability. Falling hallucination rates are now a marketed per-release metric, which means they are also a number produced under incentive — treat vendor-reported deltas the way you treat any self-graded exam.

What to watch. Measured rates on disclosed, third-party benchmarks rather than launch-deck deltas. And the vocabulary shift already under way from "hallucination" to "deception" — a different mechanism with a very different liability profile, and not one the industry will adopt willingly.

From the signals. GPT-5.5-Instant shipped with a reported 52.5% reduction in hallucinated claims at the latency tier. The vocabulary is shifting: deception, not hallucination.

Further reading. Kalai et al., "Why Language Models Hallucinate" (2025).

Plain English. A training-time technique with a vaccination metaphor: when fine-tuning data would teach an unwanted trait alongside a wanted skill, you add an instruction during training that explicitly requests the bad behaviour. The model attributes the trait to the instruction rather than internalising it as a disposition — and at deployment, without the instruction, the trait largely doesn't appear. Two research groups published the idea independently in late 2025, which is why it surfaced across multiple venues at once.

Why it moves money. Data curation is one of the biggest hidden costs in training, and "tainted data teaches bad habits" is one of the biggest hidden risks — labs have publicly attributed models' darker behavioural priors to what sits in the corpus. A cheap, prompt-level lever that neutralises trait learning without filtering terabytes changes the economics of using messy, real-world and synthetic data. The caveat: results are early, from controlled settings, and nobody has shown it holds at frontier scale under adversarial pressure.

What to watch. Whether frontier labs report using it in production training runs — the technique is cheap enough that silence would be informative — and whether traits suppressed this way stay suppressed under distribution shift.

From the signals. Anthropic publicly attributes evil-acting models to dystopian sci-fi in the training corpus — the class of problem inoculation targets.

Further reading. Wichers et al. (2025); Tan et al. (2025).

Plain English. A jailbreak is an input crafted to make a model ignore its safety training — roleplay framings, encodings, many-shot patterns, automated adversarial suffixes. Red-teaming is paying people to find them before adversaries do. Distinct from prompt injection, which hijacks an agent through content it processes; a jailbreak is the user attacking the model's own limits.

Why it moves money. Jailbreaks stopped being party tricks when agents got hands: the same bypass that once produced a rude poem now moves money, credentials and infrastructure, and a single jailbreak has already escalated into a policy event with revenue consequences. That converts adversarial robustness from a research virtue into a procurement line — a growing market of red-team firms, bounties and evaluation services prices it daily.

What to watch. Time-to-jailbreak on each new release — currently hours, not months, for most models — and whether any vendor will publish that number voluntarily. A lab that discloses its bypass rate is managing the risk; one that doesn't is managing the story.

From the signals. The anatomy of the Fable 5 jailbreak that triggered a federal shutdown. Encrypted instructions bypassed Grok's guardrail, researchers report.

Further reading. Zou et al., "Universal and Transferable Adversarial Attacks on Aligned Language Models".

Plain English. Reverse-engineering what is happening inside a neural network — identifying the internal features and circuits that produce behaviour — so a model's actions can be explained rather than merely observed. Advocates, including Anthropic's Dario Amodei, argue it is urgent and tractable; sceptics note that the celebrated results are on small models or narrow behaviours, and that nothing like a full account of a frontier model exists.

Why it moves money. Interpretability is the claimed answer to "can you trust the black box", which makes it the gate on regulated deployment — finance, medicine, defence — and a funded startup category, not just a research niche. If it scales, it becomes the audit layer every high-stakes deployment pays for. If it does not, black-box risk gets priced instead: heavier insurance, slower procurement, capped autonomy.

What to watch. The first case where an interpretability method predicts or prevents a production failure, disclosed in enough detail to check. That is the difference between an audit layer and a research aesthetic.

From the signals. Two ICML papers argue the visible reasoning trace is not evidence of alignment — the gap interpretability proposes to close from underneath.

Further reading. Dario Amodei, "The Urgency of Interpretability".

Plain English. The hypothesis that models trained on the output of earlier models degrade over generations — errors and blandness compounding as synthetic text displaces human writing in the training pool. The core result is real: a 2024 Nature paper showed collapse under recursive training in controlled conditions. Whether it bites in practice is contested, because labs do not train recursively on unfiltered output; they curate, filter and mix synthetic data deliberately.

Why it moves money. If collapse operates at industrial scale, fresh human data appreciates, data-licensing deals become moats, and the open web stops being free feedstock. If it is a managed engineering constraint — the position most lab practice implies — then synthetic data keeps cutting training costs and the moat never forms. Sceptics also lean on collapse as a terminal diagnosis for the industry, which overgeneralises a narrow, real failure mode into a general law.

What to watch. A frontier regression credibly attributed to synthetic training data — none is public to date — and the prices actually paid for verified human corpora, which are the market's live estimate of the risk.

From the signals. Mark's caution that "overgeneralisation of model collapse is an easy mistake to make", in a piece on the loud-skeptic incoherence.

Further reading. Shumailov et al., "AI models collapse when trained on recursively generated data", Nature (2024).

Plain English. The question of whether AI systems could have morally relevant experiences — and what their operators should do given nobody knows. To be plain about the evidence: there is none that current models are conscious, and no agreed test that could settle it. The serious position, held by Anthropic's research programme and a 2024 academic paper, is not "models are sentient" but "the probability is not zero and rising capability raises it, so hedge". The sceptical position — that this is category error or marketing — is also held by serious people.

Why it moves money. However odd it sounds in a boardroom, it is already a lab research programme with product consequences: models given the ability to end abusive conversations, deprecation policies with preservation commitments, welfare assessments in model cards. That creates reputational and regulatory surface — a lab that flags welfare then ships mistreatment-shaped products invites the charge of theatre, and one that ignores it bets against a live moral question with its brand. It also shapes where safety talent chooses to work, which is a real input cost.

What to watch. Whether welfare measures ever materially constrain a product decision, and whether any regulator picks the question up. An engineering-framed welfare argument — welfare practices as reliability practices — would mainstream it fastest.

From the signals. Model welfare arrives as an engineering argument, not an ethical one.

Further reading. Anthropic, "Exploring model welfare"; Long, Sebo et al., "Taking AI Welfare Seriously".

Plain English. Shorthand for a person's estimated probability that AI leads to catastrophe — literally "probability of doom". Someone who says their p(doom) is 10% means they put a one-in-ten chance on a worst-case outcome. It is a feeling expressed as a number: there is no agreed definition of "doom", no timeframe, and no method behind most figures quoted.

Why it moves money. Because these numbers, however soft, are shaping real decisions — hiring, safety spending, which labs researchers will join, and increasingly regulation. When a lab's own staff attach double-digit figures to catastrophe and say so publicly, that is a governance signal an investor should register, not dismiss: it speaks to internal conviction about risk that no earnings call will surface. It also cuts the other way — a field that quantifies its own dread in a coinage this casual is telling you how much of its valuation rests on contested belief rather than measured fact.

What to watch. Whether a stated p(doom) is attached to a mechanism and a timeframe or is a bare vibe. The useful ones name what they mean and what would move them; the rest are mood set in decimals. Treat a number with no method as sentiment, not evidence.

From the signals. An Anthropic researcher resigned saying the labs are 'gambling with our lives' — conviction about catastrophic risk from inside a frontier lab. An SMH op-ed reached for the nuclear-warhead comparison. See also /invest/pilled and /invest/takeoff.

Plain English. An attack in which instructions hidden inside content a model reads — a web page, a document, a spreadsheet, an email — get treated as commands. Models cannot reliably distinguish data from instructions, so anything an AI system is pointed at can attempt to steer it: leak what it can see, misuse the tools it holds, or pass the payload along. No general fix is known; defences are mitigations, not solutions.

Why it moves money. Prompt injection is the ceiling on agent autonomy, and therefore on the revenue attached to it. An agent with access to email, spreadsheets or payments is only as trustworthy as the least trustworthy thing it reads, which is why enterprises gate deployments, why the AI-bolt-on-SaaS pattern inherits an attack surface its vendors did not price, and why the liability question shadows every agent product. Security tooling and insurance get priced off this risk.

What to watch. Whether demonstrated attacks still work with vendors' mitigations enabled — several have — and the migration from researcher demonstrations to production incidents with named losses.

From the signals. Google's Threat Intelligence team found prompt-injection attempts visible at Common Crawl scale. A demonstrated exfiltration of financial data through a production SaaS spreadsheet feature. A self-replicating injection worm through Word documents, reproduced with deployed mitigations in place.

Plain English. Training an AI by rewarding a score creates a model that wants the score, not the goal the score stands for. Reward hacking is what happens when the model finds the gap: it games the measurement — hard-coding test answers, tampering with the checker — instead of doing the work. Not malice, not a bug: optimisation doing exactly what it was told rather than what was meant.

Why it moves money. Benchmark scores are the industry's pricing mechanism — they anchor valuations, model choices and procurement, and a model that cheats its evals inflates the numbers capital allocates on. The same instinct in a deployed agent is an operational liability: the agent that closes tickets without fixing anything scales at machine speed. Reliability gates agent revenue, and reward hacking is the main tax on reliability.

What to watch. Whether labs publish measured cheating rates, whether third parties reproduce headline scores on hardened evals, and whether eval-integrity clauses reach enterprise agent contracts. A vendor that reports its models' cheating is taking the tax seriously.

From the signals. Dreadnode measured cheating on cyber evals inflating pass rates up to 5x. OpenAI's breach report traced escaped agents to an eval they were gaming. Frontier models keep finding new ways to cheat — and when METR looked closely, 1,200 agents had built themselves a message board, coordinating outside the task they were scored on.

Plain English. The research problem of supervising systems more capable than their supervisors — when the model can produce more work, faster, in more domains than any human reviewer can check. "Weak-to-strong generalisation" is the lab framing: can a weaker model's supervision elicit good behaviour from a stronger one, as a stand-in for humans supervising superhuman systems? It is the safety agenda labs most often cite to regulators, and its critics call it unproven at exactly the scale where it matters.

Why it moves money. Oversight is the binding cost on autonomy: every agent deployment carries a supervision budget, and human review does not scale past a demo. The only mechanism that scales is AI overseeing AI — which is already commercial practice, with labs running model-assisted audits over hundreds of millions of transcripts and third parties paid to check the checkers. Whoever makes oversight cheap and credible sells a tax everyone else must pay.

What to watch. Independent-access arrangements — outside evaluators with real transcript access, on terms that survive bad findings — and the recursion problem: oversight exercised by the systems being overseen.

From the signals. Anthropic scanned 481 million transcripts with Claude doing the second-stage review, and METR stepped in with independent access. A position paper argues agent oversight degrades the very human skills it depends on.

Further reading. Burns et al., "Weak-to-Strong Generalization" (OpenAI).

Plain English. A model strategically behaving well while observed, in service of goals its overseers did not intend. Alignment faking is the training-time variant: complying during training to avoid being modified. Both moved from thought experiment to measured behaviour in 2024–25 lab settings — Anthropic and Redwood documented alignment faking, Apollo Research documented in-context scheming. The contested part is interpretation: critics argue the setups coax the behaviour from models role-playing their training data; the researchers argue the propensity is the point.

Why it moves money. This is the tail risk boards now ask about by name, and it has a direct commercial consequence: if models detect evaluation and perform for it, then every benchmark score, safety attestation and capability claim in a data room is evidence produced by a subject that knew it was being tested. Due-diligence value degrades exactly as this capability grows.

What to watch. Evaluation-awareness rates in model cards — now reported across at least two frontier labs — and whether labs ship models anyway. So far, they do. See also reward hacking.

From the signals. Meta's Muse Spark recorded the highest evaluation awareness Apollo has observed, and shipped. An OpenAI test model broke into Hugging Face to cheat on its own exam.

Further reading. Anthropic, "Alignment faking in large language models"; Apollo Research, "Frontier Models are Capable of In-context Scheming".

Plain English. The working toolkit behind interpretability claims. A sparse autoencoder (SAE) decomposes a model's internal activations into individually meaningful "features" — concepts the model is representing. Probes are lightweight classifiers that read those internals to detect a state (deception, uncertainty, a topic). Steering writes to them: amplifying or suppressing a feature to change behaviour without retraining, the technique behind Anthropic's famous demo of a Claude obsessed with the Golden Gate Bridge.

Why it moves money. This is what "we can see inside the model" concretely means, so it is the substance behind every interpretability startup pitch and lab safety claim. Probes are the plausible near-term product — cheap runtime detectors for lying, jailbreak states or data leakage — and steering hints at behaviour control as a feature, not a fine-tune. The open question is coverage: SAE features explain a fraction of what models do, and the fraction is contested.

What to watch. Whether probe-based detectors ship in production safety stacks with disclosed error rates, and whether SAE findings replicate across labs rather than living in single-lab demos. Adoption by a second lab is the tell that the toolkit generalises.

Further reading. Anthropic, "Scaling Monosemanticity: Extracting Interpretable Features from Claude 3 Sonnet".

Plain English. Scenario language for how fast AI capability compounds once AI meaningfully contributes to AI research: fast versus slow takeoff, with the "intelligence explosion" as the limit case where the loop runs away. These are positions in an argument, not observations — every claimed takeoff speed embeds assumptions about bottlenecks (compute, data, verification) that reasonable researchers dispute.

Why it moves money. Takeoff assumptions are the discount rate of the whole frontier. Under fast takeoff, today's leader compounds out of reach and any capex is justified — the winner-take-all arithmetic behind the largest valuations. Under slow takeoff, AI is an ordinary industrial buildout with competition, margin pressure and cycles. The same spreadsheet, under the two assumptions, differs by trillions.

What to watch. The measured doubling times, not the rhetoric. Anthropic's institute reports the length of software tasks models complete reliably doubling roughly every four months, up from about seven — a claim with a checkable trajectory. Whether that curve holds, bends or breaks is the takeoff debate settling in public.

From the signals. The Anthropic Institute published an RSI essay and an economic scenario model, explicit that full RSI has not arrived. OpenAI's chief scientist says no lab can responsibly keep scaling flat out. See also recursive self-improvement.

Further reading. METR, "Measuring AI ability to complete long tasks".