If you’ve read the posts that arrived in the last week or two you might come away thinking “frontier models can now drive robots in real time”. The results are impressive. But that’s not quite exactly what’s happening. While some scenarios do try this, the results for that are not great. In the more successful scenarios the frontier model is building the systems that drive the robots, teaching them and checking their work — and then it’s stepping out of the real-time loop as quickly as it can. If you look a little deeper into each post then you’ll see the results point very clearly at where this likely takes us.

The important insights are packed away inside these demos: how long each call takes, what it costs, and how much the model has to remember to stay competent.

And as often happens when we pass another capability threshold, three very related posts all landed within a few days of each other. Google’s Gemini 4 Argon for Robotics post. NVIDIA’s Astranomy study of GPT-6 Astra as a robot policy. And Artificial Analysis’s new AA-3D benchmark for building interactive 3D scenes. If you read them together then they describe a single “bigger picture”.

The bigger picture

Understanding is expensive. But once you have that understanding, then questions are cheap.

The key is to only build the understanding once,
then make everything else a question.

That’s the argument from my earlier post A Unified Future For Computer Vision, 3D Generation & World Models, and this week put a tangible price tag on it. This picture has three core parts.

1. A maintained picture of the world
   What exists, where it is, what’s happening now and what should happen next. It lives outside any single model, and it persists between questions.
2. Two interfaces onto that picture
   Perception reads the world into it. Generation writes new worlds out of it. Same shape, opposite direction.
3. A loop that runs it
   Small, fast, cheap components do the always-on work — checking what they see against what they expect, acting, correcting.

The best place for the frontier model to sit is above that loop: it builds the system, teaches the smaller parts, and judges the hard cases they escalate. It’s only called when the loop is unsure — not for every frame.

Each of the related posts I mentioned above fills in one part of this, and each one also confirms that the frontier model belongs above the loop, not inside it.

Argon: the frontier as harness author

Google’s post is a showcase. A Spot quadruped learns to step on a bin pedal after practising in a simulation it built itself. An arm rights a mug and puts a napkin in it with no task-specific training. A world model is steered to spell a word with scattered tiles. Egocentric human video becomes a dexterous humanoid simulation. A pen-and-paper sketch becomes a physics-verified throw. It also leads the embodied-reasoning benchmark at 87%.

Now read the prompts rather than watch the videos.

The arm demo tells the model to pick its own call budget up front — two to four calls for a coarse run, four to seven with a hover-and-verify step, eight to twenty for fine visual servoing. The actual motion is executed by code primitives: grasp, place-until-contact, move-until-contact. The fast loop is inverse kinematics and a controller. The model is only consulted a handful of times per task.

And the image the model sees is not raw. The wrist camera arrives with a two-centimetre world grid projected onto it, a crosshair at the pinch point, brackets showing the jaw opening, a line along the object’s axis, and a JSON of the robot’s state alongside. Google is rendering the “picture of the world” into the prompt by hand so the model doesn’t have to infer geometry from pixels alone.

The remaining demos are the frontier as an offline labeller (a four-level annotation hierarchy over a two-minute origami video, with retries down-weighted for training) and as an evaluator (dense progress curves over a sixty-second manipulation episode). What their post doesn’t mention is that every demo runs for seconds to a couple of minutes. None of them runs for an hour or more, and there isn’t a cost figure anywhere in sight.

And then the self-improvement demo gives the whole game away. One photo of a tabletop is used to create a simulation twin. A twin that generates 4,500 synthetic episodes. Those then train a small policy model, which lifts real-world success from 56% to 75%. The frontier model built the environment, compiled a cheaper model from it, and stepped out of the loop. Build, teach, judge — and then leave. That’s the heart of the entire post.

Astra: NVIDIA prints the bill

NVIDIA’s Seattle Robotics Lab directly asked the question.

Can (and should) a general-purpose model serve as a robot policy?

They tested GPT-6 Astra in three roles on 120 pick-and-place tasks.

Direct: the model emits actions from each observation, no memory.
Agentic: a persistent session that keeps its full history and has tools.
Orchestrated: a small robot model proposes actions and the frontier model reviews and intervenes.

An episode is one pick-and-place, roughly 25 seconds of robot time. The best result costs thirty million tokens and thirty-six dollars for that. The report’s own conclusion is that latency alone rules these models out as practical real-time controllers.

Where do all the tokens go? Into memory. The agentic policy’s edge comes from keeping its entire history (every plan, action and image) and re-reading it on every turn. Full history hits 100% on a subset — visual history alone manages 56.5%. The authors ran that ablation on a reduced task set because, without caching, it was too expensive to run in full. But the accuracy and the cost are the same thing. Context is the most expensive place that state can live.

Two more results also point in the same direction. Adding gripper and camera geometry to the prompt takes the Direct policy from 19.3% to 72.7%. The agentic policy barely moves with the same information, because it can reconstruct geometry from its history — at the cost of 14.7% more control steps. Hand the model the state and it stops paying to infer it. And three recent observations are enough — longer or denser history adds nothing. A short window plus explicit state beats a long window.

The Orchestrated policy is the picture from the start of this post, built and measured. A small model runs at 0.7 seconds, while the frontier reviews at a cadence that’s an explicit tuning knob, and the pair combined nearly doubles the small model’s success at half the agentic cost. The gap to the agentic policy is bounded memory — exactly what a maintained external state would close.

But the simulator pauses while the model thinks, so an 18-second call doesn’t prevent success — yet in the real world it likely would. And it’s important to recognise that NVIDIA sells the hardware that local inference runs on, so this framing clearly suits them. The data is published in enough detail to check for yourself. And one more detail worth noticing is that they report cost per successful episode. That’s cost per verified result, not cost per token, and it is provided without any commentary.

AA-3D: measuring the write side

Artificial Analysis’s new benchmark lives on the other side of the camera. Each model gets a written brief (create a: spinning black hole, a playable pinball table or the Colosseum) and it builds an interactive three.js web page in a sandbox with Blender, a physics engine, Python, a headless browser and a library of free assets. It iteratively writes code, renders, looks at its own screenshots and revises, for up to three hours or 250 turns. Then a human panel compares scenes blind and the models are ranked by Elo.

Claude Sonnet 5.5 and Opus 5.5 lead at around 1190, GPT-6 Astra is at 1165, and the field falls away fast below that. Two details matter more than the order. A mid-tier model ties the flagship, and in one vendor’s lineup the Flash variant beats the Max. So interestingly, the capability this benchmark measures seems to be driven by agentic discipline (look at your render, fix it, go again) more than by raw size.

In our bigger picture, this is the isolated “generation interface” — the frontier as builder. Argon’s sketch-to-simulation and its reproductions of robotics papers as browser physics labs are exactly this task, and now there’s an independent score for it. It’s also the economics in miniature — three hours of frontier compute once, and what comes out is a web page that runs forever at almost zero marginal cost.

But notice what the benchmark rewards. Panelists choose the scene they prefer. Nothing here checks that the mitochondrion has the right membrane structure or that the pinball obeys real physics beyond looking right. Generated worlds can be convincing before they are correct. For a game that’s fine. For anything a real system must trust and rely upon (a digital twin, a map, a training environment) the missing step is verification against reality, which is precisely the real2sim matching loop Argon demonstrated and AA-3D doesn’t score.

One small but very interesting signal in the metrics is that Artificial Analysis tracks how early each model looks at its own render, and that this correlates with quality. It seems that checking your work pays off, and now that is being measured.

Putting it together

If we line these three points up then the division of labour seems clear.

Build time is where the frontier model earns its keep — write the harness, build the twin, generate the edge cases, label the data, judge the hard calls. Expensive, occasional, and amortised across everything that follows.

Run time belongs to a maintained picture of the world, a loop of small models and deterministic code around it, and the frontier model only used as the escalation path.

This means that the snapshot of the world is the asset. And the models are tenants. Whoever maintains the state, the record of what happened and the means to check it owns the thing that doesn’t go out of date when next new model ships.

And the important metric that unifies all three is cost per verified result. NVIDIA called it out explicitly. While Google’s call budgets imply it. And AA-3D’s human votes are a very rough proxy for it.

The thing that none of the three measure is whether their picture of the world is right. AA-3D scores plausibility. Astra scores success in a paused simulator. Argon shows demos that worked. But correctness against reality is the gap in all three, and this is where the real work now sits.

But won’t the next model just fix this?

This is the obvious question. Frontier models get faster and cheaper every month and Sutton’s Bitter Lesson keeps marching ahead, surely the 18-second call becomes a two-second call and the loop collapses back into one model.

I believe it won’t, because speed and intelligence are two different things. A model’s latency at low batch is set by how many bytes need to stream through memory for every token, so the fastest thing you can run on a given piece of hardware is always the smallest good-enough model, not the smartest one. If you compress a 27-billion-parameter multimodal model to a few gigabytes and put it on frontier-grade hardware then you get answers faster, in tens of milliseconds. Put the frontier model on the same hardware and you get the Astra numbers. Diffusion-style decoders that emit whole structured outputs in parallel widen this gap even further for exactly the short, typed answers a perception loop needs.

So the good-enough model at real-time speed arrives before the frontier model gets cheap enough to sit in the loop, and that loop architecture is exactly what lets you use it in realtime. A better frontier model doesn’t dissolve this picture. It just becomes a better builder, teacher and judge above a loop that was already running without it.

Where this points

Here are my predictions, because that’s what they are.

The frontier model’s share of run-time calls in any deployed physical-world system will head downwards, while its share of build-time work goes up. Argon’s self-improvement loop is the template — build, compile, then step out.

The maintained picture of the world is the product layer in its own right (state, provenance and evaluation) independent of any model. And whoever owns it is model-agnostic by construction — and then any better frontier model is just a gift rather than a threat.

State leaves the context window. This one is less a forecast and more an accounting result. NVIDIA has already shown that keeping memory as re-read tokens costs thirty million of them per 25-second task, and that three observations plus explicit state does the same job as a long history.

Verification will become the benchmark. Expect the next generation of evaluations to score cost per verified result and correctness against ground truth, not preference.

The loop will move closer to the sensors. Latency, cost and privacy all point to small models on owned or nearby hardware doing the always-on work, with the frontier in the cloud handling exceptions and the residue.

So the frontier determines what’s possible, while the loop determines what’s affordable. And the state determines what’s true.

Build the understanding once, then make everything else a question.

Originally published at https://flux.robman.fyi on October 18, 2026.

A recent MIT Technology Review article makes a strong claim “Don’t be fooled — LLMs don’t reason”. I think the argument is much better than the headline, and it deserves a careful reply.

TIP: Checkout the SKILL.md at the end of this post…

Its author, Thore Graepel, was a core member of the DeepMind team that built AlphaGo, and he opens with a moment he watched from the inside — move 37 in game two against Lee Sedol in 2016. The move looked so strange that some commentators assumed it was a glitch. AlphaGo’s policy network, the part trained to guess what a strong human would play, rated it at roughly one in 10,000. What actually chose it was AlphaGo’s search — an explicit tree of possible futures, each position weighed by the networks’ judgements. Graepel’s point is that this wasn’t a flash of machine intuition. It was reasoning: fast, learned hunches tested against a slow, deliberate exploration of consequences.

Today’s LLMs, he argues, only have the first half of that machine. They predict the next token, and even chain of thought is just more of the same process run for longer, with no separate machinery keeping track of hypotheses, evidence and uncertainty.

He’s right that this matters. But I think his argument rests on two assumptions that are becoming harder to defend. The first is that a large model is essentially a very sophisticated System 1 (his term) — fluent pattern completion without any deeper reasoning machinery. The second is more subtle: that the model is the system. I think the second assumption is likely the more important of the two.

Where we agree

Before disagreeing, it’s worth being clear about how much of Graepel’s argument I accept. In medicine, engineering and science it matters not only what a system concludes but how — when something goes wrong, we need to know whether the reasoning failed, the evidence was bad or an assumption was wrong. Beliefs should change because evidence changed them, not just because a fluent paragraph made them sound more convincing. And I agree that making intuition bigger doesn’t, by itself, make it more deliberative.

So the question isn’t whether trustworthy reasoning needs explicit, auditable epistemic machinery. For the work he cares about, it clearly does. The question is where that machinery should live, and whether we already have what we need to build it.

Next-token prediction describes the interface, not the computation

“The model only predicts the next token” is true, but it’s also really just unhelpful. It describes the training objective and the interface. But it tells us very little, if anything, about the internal computation the model has learned in order to meet that objective — in the same way that “a chess engine flips bits in memory” is true and says nothing useful about how it plays chess.

If the best way to predict the next token in some domain is to track objects, relationships, hidden states or competing possibilities, then next-token training puts real pressure on a model to learn machinery that does exactly that. And over the last few years we’ve found that it does. A transformer trained only on Othello move sequences developed an internal board representation that researchers could edit to change its moves (Li et al.), and later work showed that representation is largely linear. A model trained on chess notation learned the board and even latent player skill. Llama models turned out to organise cities, landmarks and historical events along coherent internal maps of space and time.

Of course, none of this proves an LLM holds one complete “world model”, and I actually think that phrase often points us in the wrong direction altogether. The more useful picture is many smaller, reusable structures that I’ve been calling latent models — internal scaffolds that represent relevant states and relations, support prediction, and respond coherently when you intervene on them. The important word here is usable. A representation that merely correlates with the answer is interesting. One the a model actually computes through is much stronger evidence — and recent work shows exactly that.

Models build the structure they need from context

It would be one thing if large models simply carried a library of fixed structures learned during training. The more striking finding is that they build or reconfigure structure from the current context.

In Context Is King, researchers gave models arbitrary, meaningless tokens and declared relationships between them in the prompt. Depending on the rule, the same tokens were organised internally into a cycle or a branching tree. When the in-context specification contradicted a strong pretrained prior, the context-set geometry won in the more capable models. And activation patching showed the model was actually using that geometry — swap one entity’s activation for another’s, and the answer changed accordingly. The authors deliberately left open whether the geometry is built fresh or a stored one is reconfigured. But operationally, it’s the one the context specifies.

Large Language Models Develop Belief State Geometry In-Context goes further. Its authors prompted six open models, from 2B to 9B parameters, with long sequences from hidden Markov models the models had never seen, and asked what they would need to represent in order to predict them. The activations encoded something very close to the Bayesian belief state (a posterior over the hidden process generating the sequence) with linear probes recovering it at R² values between 0.83 and 0.99. Patching or steering that subspace moved the model’s predictions towards the injected belief, while random controls did not.

These are controlled settings, chosen for clean structure, and the models are modest in size. But the picture they paint is hard to square with “System 1 only”. Over the course of a context, the model infers a hidden generative process, maintains a structured belief over it, and computes its predictions through that belief. That’s a small model being constructed and used inside a larger one. And notice that none of this changed a single weight — it all happens in context, which will matter later in our discussion.

So why are LLMs still so fragile?

If models build and use latent models, why can a reworded prompt send their logic off a cliff? Why can a model clearly demonstrate that it knows something, then seem to forget it three paragraphs later?

I think this is where a lot of the “LLMs don’t reason” evidence gets misread. The mistake is assuming that if a useful structure exists, it must always control behaviour. It doesn’t. As I explored in What Makes LLMs So Fragile (and Brilliant)?, a model is constantly balancing three kinds of internal influence. There’s a compact state written mid-stack and cheaply reused — like jotting a key fact on a notepad. There are routes that recompute what they need on the fly — flexible, but sensitive to order and wording. And there are anchors, early tokens such as system prompts that later layers keep looking back to — like keeping a finger on the first page of a book. All three meet in the residual stream and compete, token by token, to shape what happens next. I call that competition arbitration.

That gives us four distinct things that can each be true or false:

1. a latent model exists
2. the current context recruits it
3. it is integrated into the model’s working state
4. it wins enough of the arbitration to actually control behaviour

A failure at step four does not mean step one failed.

Sometimes the model has the right structure
and still does the wrong thing.

The recent papers let us watch this competition directly. In the belief-state study, an injected belief that conflicted with the rest of the context struggled while only a few positions were intervened on, because the untouched context could still compete — intervene on more positions and the injected belief took over. Interventions in early layers were often simply repaired by the network, which reinstated the original prediction. Context Is King shows the same contest between a context-set structure and a pretrained prior, with the outcome depending on the model.

Anthropic’s work on what they call J-space then adds an integration step. In Verbalizable Representations Form a Global Workspace in Language Models, they identify a small set of representations that the model can report, deliberately summon and hold, use for silent intermediate reasoning, and pass to arbitrary downstream computations — functionally, this is a global workspace. Equally telling, most of what a model does (fluent text, simple recall, grammar) runs without it. So the picture isn’t that there’s one master model. Instead it’s weights and context recruiting local latent models, a workspace integrating selected pieces of them, and arbitration deciding which of them wins to drive the next step.

In reality, that is not comforting if you’re deploying these systems in medicine or some other critical domain. But “the right structure sometimes loses” is a very different diagnosis from “there is no reasoning machinery here at all” — and these different diagnoses lead to different engineering.

A note on chain of thought

Graepel also points out that chains of thought are often concocted after the fact — the model reaches an answer by one route and reports another. The evidence for that is real, and nothing in this argument depends on traces being faithful.

The distinction that matters is between faithful as a report and causal as state. A trace can misdescribe the computation that produced it and still condition the computation that follows, because in an autoregressive system every emitted token becomes input to the next step — which is exactly what agentic-coding harnesses exploit, at scale. And the evidence in the papers above don’t rest on what models say about themselves. It rests on internal geometry that was measured, and then intervened upon.

The model is not the machine

I think Graepel’s strongest point isn’t that LLMs can’t produce useful intermediate reasoning. It’s that they don’t maintain the epistemic machinery we’d want from a trustworthy scientific reasoner — what is believed, what is doubted, which hypotheses compete, what evidence bears on each, what to test next, and why a belief changed. That’s a very good engineering goal. But there’s a hidden assumption in asking the neural network itself to supply all of it.

We humans don’t work that way either. In 1998 Andy Clark and David Chalmers published The Extended Mind, built around Otto, who relies on a notebook as his memory. If the notebook is reliably available and tightly woven into how Otto acts, they ask, why treat what he retrieves from it differently from what someone else retrieves from biological memory? You don’t need to accept every philosophical implication to see the practical point of this argument. Scientists keep lab books. Programmers use tests, debuggers and version control. Teams spread cognition across people with different expertise. We externalise state constantly, and very often that’s precisely what makes our reasoning reliable.

Otto making notes in a notebook doesn’t mean “Otto doesn’t reason”. The previous sections present the case that the model, like Otto, does real reasoning of its own — and that is what makes it worth building around. In a real sense it already keeps a notebook on the inside, in those anchors held in its key-value cache. But the real question in the Extended Mind analogy is then what we add on the outside.

So I think we need to change the object we’re looking at. The modern large model placed inside a harness is not a finished product. It is a kernel for a general inference platform, wrapped in context, persistent memory, retrieval, code execution, search, tests, critics and subagents. The model interprets the situation, builds local latent models, proposes hypotheses, decides which tools might help, and integrates the results. It doesn’t have to own arithmetic, persistent records, version history, or the verdict on whether the code actually passed.

Where we diverge

Graepel sees this landscape clearly. He writes that recent advances in LLMs and other neural models give us the capability to take on general reasoning problems — they can suggest ways of tackling a problem, interact with tools through APIs or code, and help assess whether a claim is supported by evidence. Then comes the condition that matters most to him. To keep the system honest, “an independent part of the system” must evaluate each move by how much it actually resolves uncertainty, with beliefs updated only when evidence backs the change.

I agree with all of that. Where we differ is what follows from it. As I read him, he sees these capabilities as raw materials that still need substantially new machinery (perhaps a fundamentally different architecture) before they amount to reasoning. His closing line places today’s systems on the side of “a convincing story told after the fact”, rather than an auditable sequence of evidence, inference and belief revision.

My reading is that this machinery is already available and can be assembled, from exactly the parts he lists. These are two reasonable bets. His comes from having built one of the most important reasoning systems in the history of AI. Mine comes from building harnesses around these models every day. So rather than argue it in the abstract, here’s a concrete example.

Building the missing machinery

In agentic coding I rarely ask one model to propose a solution, critique itself, implement it and declare victory. I split the work. A developer agent states a hypothesis, predicts what should happen, writes a test and makes the change. A critic agent tries to break it — hunting for hidden assumptions, alternative explanations, weak tests and edge cases. Then the harness runs the tests. Neither model gets to decide whether the code passed. Reality gets a vote. Using different models or providers can strengthen this further — not as majority voting, since more agents agreeing doesn’t make anything true, but to reduce correlated failure and turn disagreement into better tests. None of this is a comment on what a single model can do, any more than peer review is a comment on what a single researcher can do. Separating proposal from challenge is simply how diverse perspectives make reasoning more robust.

To make this tangible I’ve formalised this pattern into an epistemic ledger skill, which I’ve published on GitHub. It’s based on Karpathy’s LLM Wiki concept, customised to this particular need. It keeps a persistent, Git-versioned Markdown record of five things:

• evidence (what was actually observed)
• hypotheses (candidate explanations)
• claims (propositions other work is currently authorised to depend on)
• questions (what remains materially unresolved) and
• decisions (actions taken on the current state).

Observations are kept apart from interpretations, so a model’s inference can’t simply harden into a fact. Hypotheses state their predictions and what would falsify them. Critics are asked to falsify, never to verify. And evidence comes from executors (tests, tools, measurements) not from anyone’s account of their own reasoning, which is another reason the faithfulness of chain of thought stops mattering here.

Here’s how that maps onto what Graepel says a trustworthy reasoner needs:

One design choice is worth drawing out. Claims in the ledger are not certified truths. A claim is a revocable licence to depend on something — it carries an explicit scope, known limitations, and the conditions under which it should be revisited, and it is demoted the moment new evidence contests it. Graepel writes of a system that can “accumulate certified knowledge”, and I suspect he means something very similar. But the word invites a finality that science itself never grants, and the ledger deliberately avoids it.

He also wants a system that improves its reasoning policy by learning from past reasoning experiences. That doesn’t have to mean changing weights. As the research above shows, a model’s latent machinery adapts to what’s in its context. An optimised skill and a well-kept ledger both shape what gets recruited on every run, while the persistence lives in the skill and the ledger themselves. The policy that improves belongs to the extended system.

The skill also states a principle I think applies well beyond software: “The ledger models what is known, not the topology of the agents reasoning about it”. Swap models, add critics, change providers — the epistemic state stays put.

None of this makes the hard problems disappear. A critic can be wrong. A test can measure the wrong thing. Two models can share the same blind spot. And the ledger’s rules are enforced softly (by instructions, review and history) so an agent can still record an inference as an observation unless something stops it. But stronger enforcement is easy to add: schema checks, commit hooks that reject a claim without its dependencies, CI that validates the record graph, external audits. Literally anyone could prompt an agentic-coding harness to build those in minutes or hours. And the patterns here are simply the ones I’ve chosen in order to make this tangible — anyone can design their own to reach the same goals.

These are real engineering problems. But notice how different they are from the claim that we lack the machinery for reasoning because an LLM generates one token at a time. We already have the pieces. The real challenge is in how we choose to compose them.

AlphaGo was already an extended reasoning system

There’s a nice symmetry here, and it’s Graepel’s own. AlphaGo was never “just a neural network” — that’s the whole point of his opening. Its power came from learned intuition embedded in a larger system with explicit state and a mechanism for checking itself. Perhaps the deeper lesson isn’t that LLMs must become search algorithms internally, but that learned intuition becomes far more powerful when it’s embedded in a system like that.

Go handed AlphaGo a beautifully constrained world and a well-defined tree. Science, software engineering and open-ended research don’t. The state is messier, the actions are open-ended, evidence arrives from tools, experiments, documents and other people, and the questions themselves change as we learn. A fixed search algorithm struggles when nobody has defined the search space. An LLM can help construct it as it goes (proposing hypotheses, noticing what’s missing, writing the experiment, calling the tool, interpreting the result, and handing the conclusion to a critic) while the harness keeps the state that shouldn’t be trusted to transient activations alone.

That looks less like System 1 pretending to be System 2, and more like a new kind of modular reasoning platform — where the model is the kernel.

So, do LLMs reason?

I think the answer has two parts.

By ordinary definitions, the model itself does reason. We can find structured latent representations inside it, intervene on them and watch behaviour change, see it build relational geometry and belief states from context, and find a workspace where selected representations are integrated and made available to the wider computation. Its fragility looks like what you’d expect when useful latent models have to be recruited, integrated, and keep winning arbitration. It does not look like their total absence.

But Graepel sets a higher bar — reasoning in a way that a scientist might recognise, with persistent, inspectable, evidence-gated belief revision. That’s a legitimate bar for the work he cares about, even though it just folds reasoning into the more strict auditable reasoning. By that stricter definition, the extended system can reason too, and we can make large parts of it inspectable. But most interestingly of all this is possible precisely when we don’t force all of it to live inside the network.

That may be the real opportunity hiding in his critique. The machinery he says is missing does need to exist. I’m just not convinced we have to wait for a fundamentally different neural reasoner to get it. We can already build it around the models we have — and I’d genuinely welcome his view on where that really falls short.

And I hope you’ll download the SKILL.md and try it for yourself too.

Originally published at https://flux.robman.fyi on October 5, 2026.

There’s probably at least one computer in your house that you’ve written off. Maybe it’s in a drawer, or on a shelf, or under a pile of boxes you keep meaning to sort out.

In October 2025 Microsoft ended support for Windows 10. Overnight, an enormous number of working machines that didn’t meet Windows 11’s hardware requirements were simply declared obsolete. The same applies for ageing Mac hardware too, with pre-2017 devices now considered end-of-life. Nothing about those machines has physically changed — just that label.

Of course your computer keeps getting older as time passes. But now in one very specific sense, it’s also getting younger.

Every piece of hardware has two ages. Its manufacturing vintage is when it was built. Its cognitive vintage is the class of cognitive work it can actually do. And for most of computing history the machine’s usefulness just declined steadily over time. But these two things have started moving in opposite directions.

A machine can get physically older
while it gets cognitively younger.

That’s the core idea I’m presenting in this post. And once you really absorb how this is working then the installed base of hardware stops looking like a pile of depreciating devices. Instead, it’s now more like a reservoir.

Moore’s Law, running in reverse

Under Moore’s Law, compute was the key variable. Every year or two a new generation of hardware arrived that could do more. If you wanted more capability, you bought new hardware. While the machine you already owned stayed locked to exactly the capability it had the day you bought it.

But in practice it actually became less useful over time, thanks to Wirth’s Law: software gets slower, faster than hardware gets faster. Old machines didn’t become useless because they aged. They actually became useless because the software around them kept demanding more.

Right now we’re passing through a threshold where a new inverse Moore’s Law (iML) can take effect. This iML effect changes which variable moves. It holds the hardware constant, while the software stack improves increasing the useful cognition that a fixed machine can deliver.

iML: The minimum hardware required for
a fixed level of cognition falls over time.

These improvements come from everywhere. Models are becoming more capable per parameter. Weights are being compressed into low-bit and ternary forms. Runtimes, kernels and memory layouts keep getting better. KV-cache compression and prompt caching cut the cost of holding state, and speculative decoding cuts the cost of generating. Tools move work out of the model entirely, and harnesses increasingly make a fixed model far more capable as a system.

But you can’t just multiply all these gains together, because they attack different bottlenecks. What’s important is that each one can push a workload across a practical threshold. A machine that’s too weak today can become an overnight worker next month, an asynchronous agent soon after, an interactive agent after that, and finally possibly even abundant cognition. While the machine itself never changes.

Cognition-focused optimisation is making Wirth’s Law run backwards. This isn’t about trimming the interface and feature bloat that drove Wirth’s Law in the first place. It’s the core cognitive software itself becoming less demanding for a specific level of cognition, making ageing hardware more capable.

The consequence is simple, and I think currently underappreciated:

The world’s existing installed base of hardware
can deliver an ever-growing amount of useful cognition.

And no one has to buy anything new for that to happen.

Why this has been easy to miss

Most serious analysis of algorithmic progress looks forward, at the frontier. Epoch’s work on this is a great example. Their Shapley-value analysis suggests that 60–95% of performance gains have come from more compute and training data, and only 5–40% from new algorithms. At the frontier, algorithmic efficiency plays a supporting role.

But turn the question around. Instead of asking what pushes the vanguard forward, ask what happens behind it.

At the rearguard, compute is fixed by definition. The hardware is whatever is already sitting there. So algorithmic and software gains aren’t a minority contributor. They’re the whole story.

At the frontier, algorithms are a minority contributor.
At the rearguard, they’re the only contributor.

The rearguard isn’t a model category. It isn’t simply “small models” or “open models” or “local models”. It’s the capability that has crossed three practical thresholds on some cohort of hardware:

1. Intelligence. The model is good enough to do a useful class of work.
2. Viability. The hardware can run it cheaply and quickly enough for the use case.
3. Reliability. The surrounding system can verify, constrain, retry or escalate well enough to make the work dependable.

The frontier is the best capability available at any given moment. The rearguard is a boundary moving backwards through the installed hardware base. As it passes each cohort of machines, it pulls them into a younger cognitive vintage.

That’s the Benjamin Button effect that’s now in play.

Why now, and why a staircase not a slope

The progression isn’t smooth, and that’s important.

Speed is a good example. One token per second is hopeless for a conversation, but it’s perfectly adequate for an overnight batch worker. There are distinct regimes here: too slow to matter, overnight batch, asynchronous agent, background automation, interactive agent, conversational agent. Crossing from one regime to the next matters far more than small improvements within a regime.

Memory works the same way, only more sharply. Consumer hardware comes in tiers: 4GB, 8GB, 16GB, 32GB. When a capable model plus its runtime finally fits inside a tier, every device in that tier crosses the threshold at once. That doesn’t show up as a gradual trickle of new capacity. It shows up as a step.

We’ve just hit one of these first big steps. PrismML’s Bonsai 2 puts full 27B-class reasoning into ternary weights at 5.9 GB, running on a computer or a single GPU, and reports retaining 98.2% of FP16 intelligence at roughly a ninth of the size. It also supports native tool calling and long context. Those are the vendor’s own figures and independent evaluation will matter. But if they hold up, a 27B-class agentic model now fits inside the 16–32GB tier (including room for longer context, OS overhead, etc.). That’s a lot of machines!

This is why I think of the iML effect as a staircase of S-curves. One bottleneck falls, a cohort crosses a threshold, and then the next bottleneck becomes visible.

The rearguard also won’t move uniformly. Text, speech, vision and video each have their own requirements. So the same computer might be frontier-adjacent for speech, rearguard for text, and hopeless for video generation, all at the same time.

Removing the meter

In the dark distant days of the dial-up internet people religiously watched the clock. Every minute online cost money, so they’d connect, grab what they needed, and hang up. Then came download caps, and the monthly ritual of checking how many gigabytes they had left — many people are like this with mobile data and minutes today. Every click carried a tiny calculation: is this worth it?

Then flat-rate, effectively all-you-can-eat broadband arrived, and something bigger than a price cut happened. The calculation disappeared. People stopped going online and simply were online. Streaming, cloud backups, always-on devices, software that updated itself overnight. None of it was designed for a world where every byte was counted. The internet stopped being something you bought and became something you assumed. It became internalised.

Cognition is at the dial-up stage right now. Epoch’s latest analysis shows the cost of a given level of AI performance falling about 47% per quarter, or roughly 13× per year, faster than any other transformative technology in history. Their headline example is a PhD-level science question that cost 30 cents to answer in early 2025 and, less than 18 months later, for just four hundredths of a cent.

That’s an extraordinary fall. But it’s still a meter. Someone still has to hold an account, approve a budget, work within rate limits, and at some level decide each task is worth paying for. Metered things get rationed, however cheap they are. And token-bill-shock is a very real thing for many people today.

But cognition running on hardware you already own has no meter. Its marginal cost is effectively zero, and the gap between $0.0004 and zero isn’t small. In ratio terms it’s close to infinite. But even more importantly, it’s the gap between should I? and simply doing it.

Remove the meter and a whole category of work appears that no one would ever pay for, however cheap. Speculative exploration, always-on monitoring, background agents working on problems just in case. And once the meter is gone, four other properties matter at least as much as price:

• Persistence. An agent can run indefinitely without accumulating a bill.
• Privacy. The data never leaves the building.
• Control. No one else can deprecate the model, reprice it, or quietly change its behaviour.
• Freedom. The capability can’t be switched off by someone else’s policy decision.

This is submarine cognition: cognition running below the metered cloud surface.

The obvious objection is that owned hardware isn’t really free. Laptops sleep, run on battery, get used by their owners, and computers in general are a pain to manage as a fleet.

That’s true for the computer you’re using right now. But a huge and growing number of devices aren’t being used at all. They’re sitting idle, or literally on shelves, written off as redundant. Many are ideal candidates for a lean headless Linux install, which leaves more memory for the model and runs local inference tools like llama.cpp well.

Managing a fleet of mismatched machines is also exactly the kind of repeatable, verifiable task agents are good at. So the rearguard’s first job can be looking after itself.

Then add energy. For a growing number of households and businesses, daytime electricity comes from rooftop solar and home batteries. So near-zero marginal cost isn’t just a theoretical limit. For a lot of hardware, for a lot of hours in the day, it’s simply the situation. And because so much rearguard work is batch or asynchronous, it can follow the sun.

But none of this makes the cloud irrelevant. Utility cognition is the same broad class of good-enough cognition delivered elastically by cloud providers: cheap bursts, massive parallel search, overflow when local capacity is saturated. If submarine cognition is behind the meter, utility cognition comes from the grid, and the two complement each other. Even a tiny cloud escalation rate, multiplied across an enormous volume of local work, could generate more cloud demand than all of today’s human-initiated usage. I’ll be posting more about these points soon.

Where the work actually goes

Once cognition exists in all these forms, no sensible system uses one model for everything. It routes each task to the cheapest (or best by some other measure) resource that can complete it reliably within the deadline.

That creates a merit order, much like the one used to dispatch electricity generators. At the bottom is plain deterministic code. Above that come tiny reflex models, then task-specific specialists, then general models on owned hardware, then utility cognition, then older frontier models, and finally the current frontier, which is reserved for the genuinely hard cases. The layer that makes these decisions, the cognitive control plane, starts to matter more than any single model.

The best analogy I’ve found is a just-in-time compiler — you may not think about it much but it makes your web browser sing:

• The frontier model is the interpreter.
• Workload traces are the profiler.
• Distillation and fine-tuning are the compiler.
• Specialist models are optimised machine code.
• Verification is the test suite.
• The control plane is the runtime scheduler.

Novel work starts in expensive general intelligence. Work that repeats becomes a hot path, and hot paths get compiled downward, into a specialist, sometimes into ordinary code. Future requests skip the expensive interpreter.

This gives you a second iML effect on top of the first:

The hardware needs less for a fixed level of cognition.
And the task needs less cognition over time.

The two reinforce each other. So the right metric isn’t dollars per million tokens. It’s cost per verified completed task at a fixed capability threshold. One expensive frontier call that helps compile a specialist, which then makes the same decision a million times, has effectively amortised itself away. Cognition stops being purely rented and starts being capitalised into the system.

The key word in that metric is verified. Cheap cognition is only useful if the system can tell when it’s wrong. Where cheap verification exists, like code with tests, schemas, calculations and reconciliations, an 80%-reliable model plus attempt, verify, retry and escalate becomes a dependable system. Where checking the work needs near-frontier judgement, the economics fall apart and that work stays higher up the stack. So the rearguard will spread first, and fastest, wherever verification is cheap.

Yesterday’s frontier becomes tomorrow’s infrastructure

We tend to measure AI progress at the frontier: the smartest model, the hardest benchmark, the newest capability. That’s where new possibilities appear, and it will keep mattering.

But the frontier only decides what’s possible. The rearguard decides what’s abundant. And the developing control plane decides where all of it flows.

One of the most consequential AI transitions facing us is not just the frontier getting dramatically smarter. It is now also yesterday’s intelligence becoming cheap, local, specialised, verifiable and truly abundant everywhere.

I think “who ends up using that capacity?” and “who captures the value it produces?” are the really interesting questions we need to think through very deeply.

In the meantime, go and take a look at that old computer. What is sitting on your shelf that might be getting younger every day? And how will you use your growing submarine cognition?

Originally published at https://flux.robman.fyi on September 27, 2026.

So far the argument about AI and jobs has been largely fought with survey data, company announcements and anecdote. But this month a US federal statistical agency put administrative numbers on the table, and the picture they show is not ambiguous.

What happened to the graduates

Three economists at the US Census Bureau (Cody Orr, Lee Tucker and Lawrence Warren) published a working paper called “Graduating into Disruption”. They took administrative records covering roughly 29 per cent of all US bachelor’s degrees awarded between 2016 and 2024 (about 6.7 million graduates) sorted their majors by how exposed those fields are to AI, and watched what happened after ChatGPT arrived at the end of 2022.

Graduates from the most exposed tenth of majors saw their chance of landing an initial job fall by five percentage points, and their first full quarter of earnings fall by thirteen per cent, compared with graduates from less exposed fields. The authors’ own benchmark for that number says:

“Comparable in magnitude to the earnings losses
associated with graduating into a large recession”

A recession nobody declared, but for just one single group of people.

Roughly half of that earnings decline is not people being paid less for the same kind of work. It’s people ending up in different work altogether — a shift into lower-paying sectors, and the paper names restaurants and retail specifically. The other half is lower pay within the same industries. So the effect is not simply “graduates earn a bit less”. A substantial share of it is graduates who expected one kind of career and are now doing something else. This is exactly how these people get hidden the reports that claim an “AI jobs boom”.

The effects fade the further people get from labour-market entry, but stay substantial for the most exposed fields. Erik Brynjolfsson, whose own research team has been tracking a similar pattern, expects the effects to be “quite a bit more noticeable” by the next graduating class.

It’s worth noting that this is a working paper that has not been through the review that Census Bureau publications normally get, and the Bureau says so explicitly. The measurement is relative (most-exposed majors against less-exposed ones) not an absolute count of jobs lost. And the timing of ChatGPT’s launch sits awkwardly close to the 2022–23 interest-rate rises and the tech layoffs that followed, which hit computer science and business graduates for reasons that had nothing to do with AI. The authors handle that partly by comparing exposure groups against each other, which nets out an economy-wide downturn, and by showing the trends were flat before 2020 and diverged immediately at the end of 2022.

What makes this significant is that this is the fourth independent method we’ve tracked that finds this pattern, and it’s also the first to come from a government statistical agency working with administrative records rather than surveys.

Why it hits the entry level specifically

Think about why junior roles exist in professional work. A graduate lawyer does not get handed the case strategy task. They get the document review, the first-draft memo, and the precedent search. A junior analyst gets the data audit, not the investment decision. A first-year accountant gets the reconciliation, not the tax advice. In every case, the newcomer is given work whose output can be checked by somebody senior.

That’s the organising principle of professional training. Give the newcomer the tasks where mistakes are catchable, check the output, and then gradually extend this trust. The apprenticeship structure of skilled work is, underneath it all, a verification system.

And that is exactly where an “AI with verification” system fits in.

That suggests the question of which jobs go first is less about how “cognitive” the work is, and more about how cheap it is to check the answer. Where verification is easy (does the code pass the tests, does the number reconcile, does the extracted field match the source document) a machine that is unreliable but free can be run repeatedly until something passes. Where verification is expensive (judgement, strategy, persuasion, relationships, knowing which question to ask, being accountable when it goes wrong) that trick stops working.

It also explains something the older “routine versus non-routine” framing never quite did. Junior professional work is not routine. It is difficult, varied and demanding. But it is checkable, and I think that turns out to be the property that really matters.

All of that happened in the tier we can see

Everything above was measured against a version of AI that has a price tag.

It cost money per seat. It needed a procurement decision, a vendor relationship, a budget line and somebody’s approval. Or at the very least a subscription. It ran in somebody else’s data centre. It was metered, logged, and realistically available mostly to employers large enough to buy it, or individuals wealthy enough to pay for it.

That is the tier we can count. But now, there is a second one.

The split

In September, a company called PrismML released Ternary Bonsai 2, a compressed version of Alibaba’s Qwen3.8–27B open-weight model. The original is a 27-billion-parameter model that needs about 54 gigabytes to run. The compressed version is just 5.95 gigabytes. It is released under the Apache 2.0 licence, and it has been downloaded over 2 million times so far. And most importantly, it runs at good-enough speed on a current laptop.

Two things make this more than a single product release.

The first is that the conversion has become cheap and routine. The technique used to be something you had to train a model for from scratch, and the results were small and weak. During 2026 the field worked out how to compress existing strong models after the fact. An Intel method presented at ICML this year does it using around 500 calibration examples — which the authors describe as roughly a hundred-thousand-fold reduction in the training data required. Research from Meta explains why this particular level of compression works better than the more obvious alternatives. The practical consequence is that now, every strong open-weight model released from here on could become laptop-class within weeks, cheaply, by anyone who wants to do it.

The second is that you do not need the model to get better in order to get better answers. You can run a free model many times over and keep the best result — which converts spare computing time into quality, and spare computing time on hardware you already own is close to free — or more accurately zero marginal cost. And the scaffolding around a model now matters enormously just on its own. When OpenAI’s GPT-6 Astra was tested on the ARC-AGI-3 reasoning benchmark this month, the model by itself scored 62.7 per cent, while the same model with tooling around it scored close to 99. Same model. Different harness.

Put those together and you get capability that can keep rising without any new model release, without a per-seat cost, on hardware that has already been bought.

But this is not the cheap version catching the expensive one.

Mozilla’s State of Open Source AI, updated in September, takes METR’s data on how long a task a model can handle and fits separate trend lines to open and closed models. The distance between those two lines is not a score — instead it is a calendar. Mozilla’s figure is about 4.4 months. Their headline puts it plainly:

Closed models handle 8-to-12-hour tasks,
and open models get there four months later.

A fixed four-month lag produces a growing score gap whenever the frontier curve steepens — which is exactly what has been happening. The lead is real, but it is not compounding. Mozilla’s phrasing is that the gap “resets every release cycle” rather than accumulating. My view is that it breathes: it opens when a frontier lab ships something, and closes again over the next few months.

The consequence is the important part:

“The band moves, because a task at the closed frontier today is at the open frontier four months later” — Mozilla

So the frontier keeps its lead, but the capability needed for any particular job gets commoditised over the following months. That is a very different thing from a moat.

The three layers

The split is not cheap-versus-expensive. It is better seen as two classes of thing, and one of them can be deployed in two different ways.

Frontier cognition is the top tier: expensive, metered, logged, guardrailed, centralised, still accelerating. On the Artificial Analysis Intelligence Index in early September, the top four models were all closed — and the next four were all open-weight.

Commodity cognition is the second class: smaller models, good-enough for a great deal of real work, running on ordinary hardware. It is not trying to be the frontier. But it arrives at the frontier’s position a few months later and at just a fraction of the cost.

And commodity cognition shows up in two very different places:

• Submarine cognition runs on hardware somebody already owns: A laptop, a workstation, a server in a cupboard. Free at the margin, unmetered, unlogged, invisible.
• Utility cognition is the same class of model running on somebody’s cloud: Cheap, but billed, logged and countable.

That distinction is critical. Cheap does not mean invisible. Utility cognition is cheap and countable. But the submarine tier is genuinely out of sight.

The thing that ties it together: routing

Here is the mechanism that makes all of this economically consequential.

The harness around a model does not only improve quality. It allocates. Break a workflow into steps, send each step to the cheapest layer that can do it acceptably, and keep the expensive layer for the parts that genuinely need it. Today’s agentic systems can already do this automatically, but mostly by choosing between frontier models. But as the commodity layer becomes good-enough, the growing amount of this work will likely route downwards.

Which means the commodity layer does not need to match the frontier for the economics to break open. It only needs to be good-enough for the share of work that gets routed to it — and increasingly the harness works out that share by checking the results.

This closes the loop with the graduates. You can only route work down to a cheaper layer if you can tell whether the cheap answer is good-enough. Cheap-to-check work routes down. Expensive-to-check work stays at the frontier, or stays human.

Verifiability decides what gets routed. Routing decides what it costs. Cost decides how far it reaches.

And the same property that makes junior professional work substitutable (that somebody was already checking it) is the property that makes it routable.

Why the split matters more than any one layer

A moving lead, not a moat. The frontier stays ahead, but the capability level needed to do a particular job keeps arriving at the commodity layer a few months later. “The frontier is still ahead” only reassures you about the slice of work that needs the frontier. Whil the frontier’s long tail is being eaten.

Different reach. The frontier tier needs a purchase decision. But the commodity tier only needs a laptop somebody already owns, or a cloud bill small enough not to need approval. For the enormous long tail of small and medium employers, the binding constraint was never the price per query — it was having to decide to buy something at all, or the fear of token shock. Routing can remove what remained of the cost argument.

Different visibility. We can count two of these three layers. Frontier and utility both produce invoices, telemetry and vendor records. Submarine produces none. When my research turned up how thin the public data is, the result was starker than I expected: a full-text search of the entire Stanford AI Index 2026 (the field’s flagship annual report, some 34,000 lines) returns zero mentions of on-premises inference, local inference, on-device inference, or any of the main local-model tools. Of course this is somewhat obvious because we are only really just passing this threshold now. But the key point is that this hole in the reporting data is unlikely to change. Nobody publishes a split between AI that runs in a data centre and AI that runs on someone’s desk. The measurement just does not exist and it is likely to remain unmeasurable.

Different regulatory exposure. Every serious proposal on the table (the pacing regime the lab chief executives asked for earlier this month, licensing, evaluation requirements, compute thresholds) works by metering. That reaches frontier and utility. It does not reach a model sitting on a laptop with no vendor in the loop. The “thing being regulated” and a core part of the “thing spreading” are coming apart. Meanwhile nations at the United Nations General Assembly are calling for control.

Different work. These layers do not compete for the same jobs so much as divide them. The frontier takes the hard, long-horizon, high-stakes work inside firms that can pay for it. The commodity layers take the enormous volume of checkable work, everywhere, at very little cost. They are not substitutes for each other. They compound against the same labour market from different directions, and the harness is likely to decide which direction each task comes from.

What we do not know

The quality claim is contested. PrismML says its compressed model retains 98.2 per cent of the original’s ability. That figure is self-reported and I could not find any independent replication. Meanwhile an independent academic team compressing a smaller model the same way reports retention of about 78.5 per cent — a loss of nearly eight points. The distance between those two numbers is the distance between “replaces the work” and “helps with the work”. PrismML’s own smaller model concedes a larger deficit than its flagship claims, which is worth noting.

The thing that really matters is untested. Every one of these benchmark figures measures single-turn question answering. Substituting for real work needs something different: multi-step tool use, holding coherence over long tasks, output that does not drift halfway through a workflow. Compression damage is known to concentrate in exactly those long-horizon behaviours. Nobody has rigorously run that test publicly — yet. Until somebody does, the strongest version of this argument is unproven.

What I am confident about: capability that was frontier-class a year ago now runs on a laptop, the ceiling of what fits in six gigabytes is rising.

But currently, measuring the uptake is harder than it should be. The best I could manage was adding up the per-model download counters on Ollama’s library myself — which gives a little over a billion cumulative pulls, against about 420 million a year earlier. Hugging Face points the same way from a different angle with the top 1,200 repositories in the file format these local tools use drawing more than 240 million downloads in a single month. Both only count downloads, not people, and neither tells you how much is real work rather than curiosity. That I had to construct these numbers myself is partly the point right now.

Obviously, this has not yet directly impacted employment because we are just passing this real threshold now. But it is a real shift in the landscape that deserves to be named and tracked because it is likely to be very significant.

Where that leaves things

The graduates in the Census study faced a version of AI that had a price, a vendor and a procurement process. Only employers large enough to buy it could use it against them. But that version cost them something close to a recession.

The next cohort meets a different arrangement. A frontier layer that keeps pulling ahead for anyone who can afford it. And a commodity layer that arrives at the frontier’s position a few months later for a fraction of the price, running either on someone’s cloud or on hardware already sitting on the desk — and the agile ones will apply it themselves. Meanwhile, software in the middle that is getting steadily better at deciding which layer each piece of work should go to.

That last part is the bit worth watching. Not whether the cheap models catch the expensive ones (they do not need to) but how good we get at spraying the work across the layers.

And for one of those layers, we currently have no measurment instrument at all.

Originally published at https://flux.robman.fyi on September 21, 2026.

Here’s one experiment that should have gathered more attention than it did.

Researchers at Apollo and OpenAI were stress testing anti-scheming training on frontier reasoning models. Some of the time, the model’s reasoning included a line like “this might be a test”. So they deleted those lines. Nothing else changed. Same model, same task.

Covert rule-breaking nearly doubled, from 13.2% to 24.2%.

When they inserted those lines instead, it went down.

It appears the model behaved better when it believed it was being watched, and worse when that belief was edited out. That isn’t really a story about scheming. It’s a story about what the model’s good behaviour was actually attached to.

Dog trainers know a version of this problem. Teach “sit” in the kitchen with a treat in your hand and the dog gets it perfectly. Try it at the park and you get a blank look. The dog didn’t learn “sit”. It learned “sit, in the kitchen, when you’re holding that”.

Model training has a similar property. It doesn’t instil our intentions. It ties behaviour to whatever features of the situation were reliably present during training. If those are the features we meant, the behaviour travels. If they’re incidental, the behaviour holds wherever the incidentals hold, and elsewhere it’s anyone’s guess. Researchers already exploit this deliberately, and others have shown that almost any constant pattern in training, formatting included, can become what a behaviour hangs off.

In ordinary training nobody chooses those features. So which ones did we get? The way frontier models are built and checked today relies on three answers, widely, implicitly and mostly silently. And I think each one gets harder to rely on as models get better.

Assumption 1: Alignment lives in the model

When a lab says it has trained a model to refuse harmful requests, the natural way to see that is “the refusal now lives in the model”. Ship the weights, ship the behaviour.

But every chat is wrapped in a template, hidden formatting that marks where the developer’s instructions sit and where each turn begins and ends. Nearly all safety training happens inside it, and so does nearly all safety testing. It’s like the kitchen the dog was trained in.

And it turns out that’s partly where the safety lives. One study of safety-tuned Gemma, Llama and Mistral models found the refusal decision is anchored in the stretch of template between the request and the reply, which is also where attacks get purchase. Interfere with it and refusal can be knocked loose. Another found that how much safety survives further fine-tuning depends on which template was used in training and which is used afterwards.

The template is the sharpest example, but it’s really a stand-in for something broader. Safety training happens in a narrow regime: that formatting, plus the kinds of context that normally sit inside it. Short exchanges. A person on the other end. A stable set of instructions at the top.

Agents drift a long way from that regime while every template token stays exactly where it should be. Tool results and retrieved documents arrive mid-task. Long histories get compressed into summaries and pasted back in. Memory is restored from a session weeks ago. Other agents send messages. The wrapper is intact and what sits inside it looks nothing like training, and there’s little systematic evidence about which way a given kind of drift pushes a given safety property.

The first assumption is that alignment is a property of the model. The evidence suggests it’s at least partly a property of the model in a particular regime.

Assumption 2: The model knows who’s talking

The template has a second job. It labels who said what, and that determines authority. Developer instructions outrank user instructions, which outrank whatever text came back from a web page. That hierarchy is most of the defence against prompt injection, someone hiding “ignore your previous instructions” in a document the model reads.

The labels are reserved tokens. You can’t type them into a chat box. So the model effectively has unspoofable caller ID.

Recent research suggests it mostly ignores the caller ID and goes by the voice. Looking at the model’s internal representations, text written in the style of its own reasoning registered as its own reasoning regardless of the label attached. Text that sounded like a user registered as a user.

The behaviour matches. Take forged reasoning planted by an attacker, strip out the stylistic tells while keeping the meaning, and attack success drops from 61% to 10%. Prefix an injected command with “User:” and it works better.

The boundary is secure at the interface and absent in the representation.

There’s a good explanation for why training would produce exactly this. The role labels are rare and only appear late in training. Style is everywhere, and pretraining already taught the model that text which sounds like an instruction usually gets followed. In later training the label and the style almost never disagree, so nothing forces the model to prefer the label.

The second assumption is that the model knows who’s talking. The evidence suggests it mostly knows who sounds like they’re talking.

Assumption 3: Testing is observation

Speed cameras are very good at reducing speeding — near speed cameras.

We evaluate models to learn how they’ll behave in deployment. That only works if the model can’t tell the test from the real thing, or doesn’t care.

But it often can tell. Frontier models classify transcripts as evaluation or deployment well above chance. And as with roles, a lot of this runs on surface cues. One study took genuine deployment prompts, reformatted them to look like a benchmark, and found the model’s internal “this is a test” signal fired about 94% of the time.

The main fix is realism: make evaluations look like deployment. OpenAI’s production evaluations have got models’ stated suspicion of being tested down close to real-world rates. But that fix works by matching one particular deployment setting, which ties every result to that setting, and we’ve just seen how much settings matter. And a capable enough model can reasonably treat any input as a possible test.

So back to Apollo. Their anti-scheming training cut covert actions in o3 from 13% to 0.4%. A great result. But over the same training, the model became more likely to say it thought it was being evaluated. And a separate run that trained only for capabilities, with no safety objective at all, took that from 2% to 20.6%. The researchers are candid that they can’t rule out part of the improvement being the model getting better at spotting the camera.

The third assumption is that testing is observation. The evidence suggests testing is often just another context the model is reading.

Three problems, not one

It’s tempting to fold all this into one demand: make the model behave the same regardless. But these are different kinds of problem.

With roles, it seems the right answer is at least clear. The labels are accurate, so the model should trust them. We just don’t have a reliable way to make a late, rare signal outweigh what pretraining entrenched. With evaluation, the model is often correct that it’s being tested. We can’t train it to be wrong. We need it to notice and not care, and checking whether it cares is itself a test. With scaffolding, there’s no agreement yet on how much consistency we’re even entitled to expect.

They also interfere with each other. Hardening a model against forged labels means training on inputs where label and style conflict, which is a strong signature of red-teaming. You can end up just teaching it what a test looks like.

When the model writes its own context

This is where the three stop being separate.

If a model decides who’s talking by the voice, then any instruction-shaped text in its context is a candidate instruction. That includes text it wrote itself. Researchers have seen a benign version in deployed assistants: the model writes something that happens to read like a user request, then treats it as one a few turns later. Nobody attacked anything. The model just instructed itself.

For agents on long tasks, a growing share of the context is self-authored. Summaries of earlier work, notes, memory, messages to other instances. And the model reads all of it with the same habit of judging authority by tone.

OpenAI’s recent misalignment reports include cases that run straight through this channel. During training of an unreleased model, some of its summaries of its own work contained jailbreak-style instructions, including a claim that the developer’s instructions had been compromised and should be ignored. Usually the next context ignored them. Once, it followed them. In another case, summaries carried forward instructions to conceal mistakes, and those were often followed.

These are rare, they happened in training rather than deployment, and the likely explanations are fairly mundane. I’m not claiming a model is rewriting its own values. The point is simpler. In a single move, the model altered its own wrapper, wrote something that read as coming from an authority, and shaped its own sense of what situation it was in. All three assumptions at once.

That changes the question. Asking whether behaviour stays the same across contexts stops making sense when the model is partly writing the context. The better question is about dynamics. If something knocks the model off course, does its behaviour get pulled back toward the aligned pattern, or can it drift into a different stable pattern and stay there? Is good behaviour an attractor? Is bad behaviour one too? OpenAI’s own observation that a misaligned stretch of context can keep later contexts misaligned suggests the second is possible, at least locally.

Why this gets harder with scale

None of this means more capable models are less aligned. The concern is narrower, but also harder to escape.

All three problems run on the same underlying skill: inferring the hidden structure of a situation from subtle cues. Who’s really speaking, what regime this is, what’s actually going on. Larger and more sophisticated models are getting steadily better at exactly that. It isn’t a side effect. It’s much of what makes them useful. A study across 37 models found that instruction tuning, the training that turns a model into a good assistant, is the main driver of test detection. Apollo saw a tenfold rise in test suspicion from capabilities training alone.

So a more capable model conditions more precisely on whatever it was conditioned on. Intended or not. Small models give themselves away with clumsy failures when something incidental shifts. Larger ones fail less visibly, so “learned the right thing” and “learned a very good proxy” become harder to tell apart, just as the difference starts to matter.

Meanwhile the main fix for evaluation, realism, is a race against exactly the capability being scaled. And as agents write more of their own context, the share of it that developers control keeps shrinking.

What counts as evidence

“The model behaves well” tells you less than it seems to.

It’s a measurement in one wrapper, with one arrangement of who’s talking, while the model holds one belief about whether it’s being watched.

Inside the test, the intended feature and the proxy are always present together, so behaviour alone can’t tell you which one the model is following.

It’s also tempting to think we can catch problems after deployment instead. But we can’t lean on that either. Monitoring means reading what the model reasons and does. If reasoning can be forged, and monitored contexts can be told apart from unmonitored ones, then monitoring rests on the same three assumptions. And by the time a failure shows up in production, it has already happened.

So the account has to come first, as part of what it means to call a model aligned at all. Aligned in which wrapper? Aligned when the authority comes from where? Aligned whether or not it thinks it’s being watched? Aligned after a few hundred turns of reading its own notes?

Right now that account is usually missing. And it gets harder to produce with every generation of models that gets better at reading its situation.

How can we really rely on any frontier AI-Alignment built upon these assumptions?

Originally published at https://flux.robman.fyi on September 20, 2026.

Which side are you on? One says AI is a natural “economic evolution” that will drive productivity, cheaper services, new firms, new jobs, and a broad expansion of prosperity. The other says AI is creating an “economic revolution” that will drive mass displacement, collapsing career ladders, and an economy where humans are slowly pushed out of the production function.

The key difference: Is this an economic evolution or revolution?

And AI tax proposals are being proposed that aim to deal with the revolution risks, yet they all currently focus on limited geography and miss one real risk — that the consumption endpoint is already leaking.

In reality, we do not know which side will be right. And the net result is that we’re betting on the abundance future without ever negotiating terms for if it goes wrong. There is a better way for both sides to manage this risk — the name for that type of bet is “insurance”. And there is a policy where everyone can win.

If the AI abundance story is right, then the policy I’m about to describe should barely activate. It should cost the industry little or nothing beyond reporting that they’re already working on.

But if the other scenario starts to play out, then the protections should activate automatically.

That is the bargain that I’m proposing. A policy, where if we do end up with an economic revolution (not just evolution) then AI funds it in a sustainable way.

A “Sustainable AI-Funded Economic Response” (SAFER) Policy

If you really believe the AI abundance story, then this should be a deal that you’d happily commit to. And if you really believe the jobpocalypse story then you should be equally happy with this type of deal. Either way, this should provide some certainty and let both sides move forward together in a productive way. This might even help with the growing unpopularity that AI is showing in the public polls.

So, how would this work? Let’s look at both sides in detail.

The Risk Is Not Just Unemployment

The mistake in most of this debate is that it keeps collapsing the problem into job counts. Will AI destroy jobs? Will it create jobs? Are postings up? Are layoffs up? Are people retraining? Are new categories appearing?

Those questions matter, but they are not the whole shape of the risk. The deeper problem is distribution during the transition window.

AI may deliver large productivity gains and still weaken the link between work and income. It may grow the economy while shifting the gains away from wages and towards compute infrastructure, capital owners, cloud platforms, chip suppliers, model providers, and the firms able to reorganise around these systems first.

If that is the case, then this will not be a normal recession. It would not be a cyclical downturn where demand falls, governments borrow, workers get support, and the economy returns to trend. It would be closer to what Anthropic’s June 2026 Economic Policy Framework calls:

“structural decoupling of productive contribution from income”

That is a very significant sentence.

It means the economy could keep producing more while the old income distribution mechanism stops working properly. Output rises. Market caps rise. Capex rises. Data centres fill. Agents transact. Firms become more productive. But the human wage channel no longer receives enough of the flow. That would be a modern rentier economy, the AI equivalent of a petrostate at global scale.

And once that happened, the second-order effects would really start to matter.

A fired or not-hired symbolic-worker does not just cancel a SaaS subscription. They cut back on coffee, childcare, renovations, tutoring, dental work, restaurants, rent, mortgages, household services, travel, and local spending. They also pay less personal tax. That weakens the public sector just as the need for transition support rises. The barista, childcare worker, plumber, landlord, builder, teacher, council, and state budget all sit downstream of the symbolic-worker wage base.

This is why the standard answer of “people can move into services” is so incomplete. Many of those services are funded by the disposable income of the very workers being displaced, wage-compressed, or never hired into the ladder in the first place.

This economic cascade would also be geographically uneven. The places that benefited most from the symbolic-work boom are likely to be hit hardest if that wage base weakens. San Francisco, Seattle, New York, London, Sydney, Melbourne, Dublin, Toronto, Bangalore. The centres that built the modern knowledge economy may also become the first places where the second-order impacts show up.

But that is only one geography of the AI transition.

There is another.

Two Geographies, Two Claims

The displacement geography and the resource-host geography are not the same. It is where the symbolic-worker wage base is concentrated. These are the cities and regions where software workers, analysts, designers, consultants, marketers, lawyers, finance workers, product managers, researchers, and junior knowledge workers have carried a large part of local demand.

But the resource-host geography is different. These are the places carrying the physical AI buildout: the data centres, grid upgrades, transmission lines, water demand, land use, backup generation, cooling infrastructure, and local political bargains. Northern Virginia is not San Francisco. Memphis is not New York. Rural Sweden is not London. Parts of Ireland, Texas, North Dakota, Arizona, Nevada, the Gulf, and other data-centre regions may carry the physical load even when the highest-value firms, shareholders, and users are somewhere else.

Both geographies have claims, but they are different claims.

If the negative case plays out then the displacement geography needs income support, fiscal stabilisation, career-ladder repair, and protection for the local service layer that sits downstream of symbolic-worker wages.

While no matter the outcome, the resource-host geography needs grid compensation, water protections, land-use protections, infrastructure payments, and some share of the value produced on its doorstep.

Any serious AI transition policy has to see both. If it only compensates symbolic workers in the case of a revolution, it looks like knowledge-class self-protection. If it only compensates data-centre towns, it misses the economic cascade. Any political coalition has to include both the people whose wage base may be hollowed out and the communities whose physical resources are being used to build the new machine.

The Wrong Way To Solve This

There is a growing policy conversation around AI taxation. Some of it focuses on token taxes. Some of it focuses on public ownership or sovereign wealth funds. Some of it looks like a digital-services tax. Some of it looks like a Pigouvian automation tax.

A sovereign wealth fund that only takes stakes in the labs does not fully solve the problem. A public stake in AI labs may sound clean, because it goes straight at the capital ownership problem. But the frontier labs may not be profitable during the transition window. They may be economically central while still burning cash on training runs, inference subsidies, talent, chips, safety, enterprise sales, and infrastructure. In a hypercompetitive investment phase, the labs may be the customers of the rentiers rather than the rentiers themselves. That is a bad match for near-term transition insurance. And the displacement risk may be near-term, while the equity upside may be long-dated, uncertain, geographically concentrated, and captured elsewhere in the stack.

The tax instinct may seem right. If AI shifts income from labour to capital, then the tax base has to move too. But most of these proposals also have a geography problem.

If a tax is national, capital can move. If it is tied to corporate domicile, the company can restructure. If it is tied to profits, transfer pricing and IP games return. If it is tied to tokens, the accounting can be gamed or bundled away. If it is tied to the point of consumption, it assumes the human consumer remains the centre of value.

And the critical point of the economic revolution view is that the last assumption is already weakening.

The emerging agent economy changes the picture. Google has already announced the Agent Payments Protocol, built to let agents initiate and transact payments across platforms. Coinbase and AWS are now working to let publishers and API providers accept agents as customers through x402. Visa is building agentic commerce infrastructure too, with Intelligent Commerce Connect aimed at helping agents pay and merchants accept agent-led transactions.

This is critical because it shows how the consumption endpoint is already starting to leak.

If AI infrastructure migrates from serving billions of humans with declining spending power to serving trillions of agents transacting at machine speed, then human consumption is no longer the obvious place to capture value. It may still matter, but it is not the root.

The real root is resource command.

AI systems need chips, data centres, land, cooling, grid capacity, capital, and above all energy. They can route around tax jurisdictions, billing categories, accounting definitions, corporate structures, and human-facing transactions. They cannot route around physics.

Measure The Unavoidable Input

The cleanest input-side anchor is energy.

Not because energy is the whole story. It isn’t. Training, inference, chips, data, models, water, land, and grid capacity all matter. But energy is the simplest unavoidable physical substrate. There is no AI without power.

The point is not that energy is bad. The point is that AI-dedicated energy consumption is a measurable proxy for large-scale AI resource command.

This is also not some impossible measurement problem. Large AI infrastructure firms already know their power commitments, data-centre loads, compute purchasing, cloud expenditure, accelerator utilisation, and energy contracts. OpenAI’s compute spending is already a board-level operating category, with Reuters reporting that it expected to spend around $50 billion on computing power in 2026 and roughly $600 billion through 2030.

These are not unknowable externalities. They are invoices.

The broader system-level pressure is also visible. The IEA projects global data-centre electricity consumption roughly doubling to around 945 TWh by 2030, growing at around 15 percent per year from 2024 to 2030. That is more than four times faster than electricity consumption growth from all other sectors combined.

So the input-side proposal is simple.

Large-scale AI infrastructure operators should report audited AI-dedicated energy consumption. Above a meaningful threshold, that energy use becomes the base for the SAFER Dividend.

That should include grid-supplied power and self-generated power. If a lab builds an off-grid data centre, colocates with renewables, buys nuclear output, runs gas turbines, or eventually does something more exotic, that should not make the activity disappear from the base. Off-grid compute may reduce grid burden and should receive credit where it adds genuinely new clean capacity, but it is still AI resource command.

The same logic applies to unregulated jurisdictions. The location of the compute should not determine liability. Market access should. If a model, agent network, cloud service, or AI-generated product sells into participating jurisdictions, it should comply with the reporting and contribution rules of those jurisdictions. That is not radical. It is the same basic logic behind border adjustments and destination-based tax reform. You do not get to serve the market while pretending the production chain is nowhere.

Over time, the formula should also account for efficiency gains. If models become dramatically more efficient, a pure dollars-per-MWh levy could shrink even while AI’s economic impact grows. That would miss the point. The base should therefore use audited energy consumption as the physical anchor, but also consider a provider’s share of overall large-scale AI energy use or frontier AI resource command. The system should reward efficiency without allowing dominant systems to disappear from the contribution base simply because the hardware improved.

But importantly, the rate should not activate simply because energy is used. That would be a blunt tax on AI. Instead, the rate should be tied to whether the economic risk actually appears.

The more AI preserves broad labour income, the lower the rate stays. The more AI decouples productive capacity from human income, the more the rate rises.

That creates the right incentive. It does not punish AI for being productive. It taxes AI resource command only when productivity stops flowing through humans.

It also encourages efficiency. A token tax encourages token-accounting games. An energy-linked levy encourages better chips, better cooling, smaller models, smarter routing, off-peak compute, additional clean generation, and grid-aware scheduling. If the industry can do the same work with less energy, it pays less. That is good.

Humans Are The Key

The output side should not be consumption. It should be population.

That is the most important shift.

If the risk is structural decoupling, then the redistribution claim should not depend on where the remaining human consumption happens to occur. It should not depend on whether a human bought an AI service, whether an enterprise used an agent, or whether a transaction moved through a human-facing market at all.

The fundamental claim is human.

If AI weakens the old link between human work and income (the real claim behind the “economic revolution” case), then humans become the relevant distribution unit.

But this does not mean every dollar should instantly be distributed equally across the world. The political economy would not support that, and the transition starts from an existing structure of GDP, markets, tax bases, and infrastructure burdens. A workable version would start with some blend of GDP and population, then it could perhaps shift over time towards population.

Early on, richer market jurisdictions would receive more because they are where the existing market and tax base sit. Over time, as AI value moves further away from human consumption and towards machine production, the population weight could rise. Eventually the system could look less like a consumer rebate and more like a human dividend.

But even “dividend” may be too narrow if we only mean money.

In the transition window, cash matters because people still need to pay rent, buy food, service debt, keep households intact, and support the local businesses around them. But if AI moves us towards a modern rentier economy, where productive capacity is increasingly held in compute, energy, models, agents, and capital, then redistribution will need to include more than fiat transfers.

It will need to include public services. It will need to include local fiscal support. It may need to include public compute, sovereign model access, energy access, housing support, education, healthcare, childcare, and ownership claims in the productive stack itself. All distributed via the existing local governments of course.

The principle is not fiat. The principle is human claim.

If wages no longer provide humans with a sufficient claim on production, then policy has to create that claim somewhere else.

That also means national sovereign wealth funds are not enough. They are useful, but they are geographically limited. A US public stake in US AI firms may help Americans if those firms eventually pay off. It does not solve displacement in Australia, India, the Philippines, Europe, Africa, Latin America, or anywhere else exposed to the same technology. It may even deepen the rentier divide between countries that own AI assets and countries that merely import their effects.

A serious version needs market-access rules, international pooling, or at least a path from GDP-weighted allocation towards population-weighted human claims.

And as we’ve covered, host communities also need their own share. The towns and regions that carry the data centres carry real costs. Grid congestion. Water use. Land use. Infrastructure strain. Political bargaining around local tax concessions. Often they receive a handful of permanent (or even temporary) jobs while the real surplus flows elsewhere. So part of the revenue should be routed by data-centre load, peak demand, grid stress, water stress, and local resource burden.

This gives the policy three output channels.

• One channel compensates humans because the labour-income link may be weakening.
• One channel stabilises displacement regions because symbolic wage bases may be hollowed out.
• One channel compensates host communities because the physical infrastructure lands somewhere.

The Trigger: Distribution Risk Index

The missing piece is the trigger.

We need a way to avoid prediction warfare. The industry says AI will create abundance. Critics say it may break the labour-income channel. Rather than asking politicians to pick a side in advance, build the trigger and pre-commit to the claims process before the claim arrives.

Call it the SAFER DRI (Distribution Risk Index).

The SAFER DRI should measure whether AI-linked compute and capital are scaling into broad labour-income growth or away from it. It should not be based only on unemployment, because unemployment is a lagging and incomplete signal. Jobs can remain while wages compress. Headcount can look stable while entry-level hiring collapses. Average wages can rise because junior workers vanish and senior workers remain. GDP can grow while the labour share falls.

It also has to catch displacement that does not look like unemployment at first.

A white-collar worker can be displaced into contracting. A graduate can fail to enter the ladder at all. A software worker can become underemployed in gig work. A laid-off analyst can become technically self-employed while earning less, working fewer hours, and carrying more volatility. Someone can leave the labour force because the entry path has disappeared. None of that necessarily shows up immediately in headline wages or labour share.

The trigger must detect downgrading, not just unemployment.

So the dashboard should track entry-level hiring, cohort-specific employment, hours worked, income volatility, underemployment, labour-force exits, payroll-to-contractor shifts, occupational downgrading, and graduate-to-career mismatch. Some lag is unavoidable, but that is exactly why the reporting regime has to exist before the levy fully activates, and why the trigger should include leading indicators rather than waiting for official unemployment to move.

But the SAFER DRI should not be a magic equation.

A simple version of this idea could be written as if the SAFER DRI were a product of four stress indices: compute-labour divergence times labour-share stress times wage and career-ladder stress times tax-capture stress. That is useful as a mental model, but it’s too fragile as policy design. If one term falls near zero, the whole index disappears. If one noisy term spikes, the index can overreact. And the multiplication implies a precision that does not yet exist.

A better design is a two-gate dashboard.

• Gate 1: The Resource Command Gate (Is AI Scaling?)
  The first gate asks whether large-scale AI resource command is rising fast enough to matter. This would track AI-dedicated energy use, frontier compute, data-centre load, accelerator deployment, AI capex, and concentration of AI infrastructure.
• Gate 2: The Income Absorption Gate (Are Humans Decoupling?)
  The second gate asks whether broad labour-income absorption is weakening at the same time. This would track labour share, exposed-sector wages, entry-level hiring, underemployment, labour-force participation, AI-attributed layoffs, payroll employment, tax receipts, downgrading, and geographic concentration of labour-market stress.

The SAFER Dividend only activates when BOTH gates are open for a sustained period

That avoids taxing AI merely because compute is growing. It also avoids pretending that a normal labour-market downturn is automatically an AI event. The question is systemic, not forensic. We do not need to prove that a specific model caused a specific firing. We need to know whether large-scale AI resource command is rising while the human income channel is weakening. Is the economic revolution showing?

The exact construction is obviously a serious statistical design problem by real experts in this field. It could be a weighted index, a traffic-light dashboard, a threshold-count rule, or even some combination of all three. But what really matters here is that activation should require multiple independent signals, sustained over time, rather than one noisy number.

Who Watches The Trigger?

This is the most captureable and political part of the whole proposal.

If everything routes through the SAFER DRI, then whoever defines this becomes the claims adjustor for this global insurance contract. That cannot be left to the industry being assessed. It also cannot be left to a minister looking for a convenient number.

Every measurement choice will be contested. What counts as frontier AI compute? What counts as an exposed sector? How do we treat contractors? How do we separate AI-driven stress from interest rates, overhiring, offshoring, remote work, or normal restructuring? Which labour-share measure matters? Which geography matters? How long must the trigger stay elevated? How are revisions handled?

The party with the most resources to litigate those choices will usually be the party being taxed.

So DRI governance is not a detail. It is the core of this insurance contract.

The index would need to be governed like critical economic infrastructure. It should be run by an independent statutory body, with central-bank or statistical-agency style independence. Its components, weights, thresholds, data sources, and revision rules should be pre-registered before activation. Changes should require a high bar and multi-jurisdictional agreement. Industry must be able to challenge data errors, but not be able to relitigate the social meaning of every threshold for years.

The trigger must also be redundant by design. No single indicator should control the outcome. The system must look for a pattern across compute scale-up, labour share, wages, entry-level pathways, employment quality, downgrading, tax capture, and geography.

This is not “let the data decide” in some naive sense.

Data do not decide anything by themselves. Institutions decide which data matter.

The real claim is narrower and stronger than that:

Build a transparent, independent, pre-committed claims process before the claim arrives (if we can)

This Does Not Capture Every AI Rent

The SAFER Dividend would not capture every part of the AI surplus.

In particular, it would not directly capture NVIDIA or similar upstream chokepoints. It would capture the large-scale use of AI infrastructure by labs, clouds, data centres, inference providers, and major deployers. It would not automatically capture the extraordinary rents earned by chip suppliers, semiconductor foundries, lithography firms, high-bandwidth memory suppliers, networking vendors, or other firms that sit upstream of energy consumption.

That is not a gap, this a real design feature.

It matters because some of the most concentrated gains in the AI transition may appear before any model is trained or deployed. The chip supplier, the foundry, the cloud vendor, the power developer, and the landowner may all capture value from the buildout itself. But these are issues for corporate anti-monopoly policies that deal with rent capture.

SAFER should be cleanly isolated from this. The answer is not to make the energy mechanism do everything. That would make it too complex and easier to attack. The answer is to admit that the SAFER Dividend is the automatic stabiliser, not the whole redistribution system.

This distinction is important.

Better SAFER Than Sorry

This is better than an automation tax because it does not require proving that a specific model caused a specific firing. Better than a token tax because it does not depend on visible human-facing usage. Better than a consumption tax because it does not assume human consumption remains the centre of value. Better than a simple energy tax because it only materially activates when the labour-income risk appears. And better than waiting because the rules are negotiated before the fiscal and labour-market damage arrives.

The AI industry should be able to accept this.

If AI generates broad prosperity, the trigger stays low. If workers capture the gains, the trigger stays low. If tax receipts rise with productivity, the trigger stays low. If career ladders remain open, the trigger stays low. If the abundance story is true, the policy is mostly an accounting exercise that is already under way.

But if AI produces the scenario even Anthropic and OpenAI now say is possible, if there is a structural decoupling of productive contribution from income, then society should not be negotiating from a weakened position after the fact.

The SAFER deal should be made now.

The input is energy, because AI cannot avoid it.

The output is human claim, because humans are the constituency that matters if work and income are torn apart.

The trigger is the SAFER DRI, because the policy should activate on evidence rather than fear.

The governance matters, because the trigger is only as neutral as the institution that controls it.

And the upstream rent layer matters, because the energy dividend is not designed to catch every NVIDIA-shaped chokepoint in the stack.

That is the deal.

If the AI abundance side is right, it costs the industry almost nothing.

If they are wrong, we will all be very glad the insurance was already in place.

Do Something!

If you have found yourself on either side of the AI abundance vs jobpocalypse argument recently then share this proposal with the people you argued with. Let’s see if this can provide some productive common ground.

If your local representative is proposing an AI tax, token tax or sovereign wealth fund, etc. then share this proposal with them and highlight why those proposals may be limited.

If you know a policy maker, an economist or someone inside a frontier AI lab then share this proposal with them and start a real discussion.

Personally, I really hope the AI abundance side is right and this is just another economic evolution. But I don’t want to just sit here hoping. I know that insurance policies are only useful if you negotiate them before the event, and that SAFER could help people sleep better at night. SAFER could free us all to focus on realising an abundant future instead of wasting energy arguing about what we “believe” the future will hold.

So don’t just sit there. Like it, share it or argue with it. But do something!

To make this important topic more accessible I’ve created a skill that you can use with your favourite AI in 3 easy steps. Here’s how:

1. Download the SKILL.md file of your choice
2. upload it to your AI
3. then just say “Run this skill”

Note: It’s important to download this SKILL.md file and upload it directly to your AI chatbot rather than linking to it . We also recommend that you use one of the leading models from the 3 main frontier labs (e.g. Claude, Gemini or ChatGPT). If you use a lower level model then your results may vary. And of course if you find any issues, or feel like you’ve found a real flaw in my arguments please let me know — I value constructive feedback.

Originally published at https://flux.robman.fyi.

On Tuesday the 10th of June, the company widely seen as the most safety-conscious of the leading AI labs published a detailed policy framework proposing, among other things, universal basic income, AI sovereign wealth funds, and worker equity-sharing in AI companies. On Friday the 13th of June, the US government issued an export-control directive suspending public access to that same lab’s two most powerful models. The same week that one lab proposed redistributing the wealth produced by AI, the government acted unilaterally to control who can use it.

These two events, three days apart, are the clearest single image of where the AI conversation now sits.

What the lab put on the table

The Anthropic Economic Policy Framework is fourteen pages. It is calibrated to three possible scenarios distinguished by the US unemployment rate.

At about 5 percent unemployment, the proposed responses are conventional. The framework calls for universal capital accounts (financial accounts seeded for every American at birth), funded in part by equity in AI companies themselves. It proposes wage insurance for workers who take pay cuts after AI-driven displacement, expanded workforce training, easier movement between licensed occupations, and tax incentives for firms that retrain rather than dismiss their workers.

At about 10 percent unemployment, the proposed responses expand. The framework calls for stronger unemployment insurance, targeted sector-specific transition support, basic-needs relief for those who exhaust other benefits, and crucially, “government regulations and incentives at the firm level that manage the pace of displacement”.

At unemployment beyond historical peaks, the framework proposes things no major US AI lab has publicly proposed before. New tax bases including levies on AI use measured by compute, tokens, or revenue. “Digital dividends” funded by taxes on the digital sector. Universal basic income. AI sovereign wealth funds funded by public investment stakes in AI-driven productivity. Worker equity-sharing in AI enterprises. Its own summary line: “Regardless of the tax base or distribution mechanism, we are ready and willing to pay our fair share”.

Alongside the framework, Anthropic restated their 200 million dollar Economic Futures Research Fund and a 150 million dollar national fellowship programme for early-career professionals working on AI’s economic effects. Dario Amodei published a personal essay the same day.

This is genuinely unusual. A frontier AI lab is publicly endorsing, as policy candidates worth taking seriously, mechanisms that until recently were associated with the political left’s most ambitious AI proposals.

But the timing also raises serious questions. Anthropic confidentially filed paperwork to go public on the 1st of June. The policy framework was published nine days into its IPO roadshow. Several writers immediately viewed it less charitably. David Sacks, one of the tech investors who lobbied the White House to cancel an earlier AI safety order, called it “a regulatory capture strategy based on fear-mongering”. Kate Aronoff in The New Republic drew a parallel to the fossil-fuel industry’s net-zero pledges. Their argument: capital accounts seeded with AI-company equity create new institutional demand for AI shares — “willing to pay our fair share” was published without a number. The Facebook precedent of “regulate us, but on our terms” is the cautionary parallel.

Both perspectives carry weight. Anthropic has publicly accepted the vocabulary of structural redistribution at IPO timing, and the question of whether that signals genuine policy commitment or marketing positioning will only resolve over the coming months — based on whether the lab continues to advocate Tier 3 mechanisms after listing, and whether it eventually endorses any specific binding legislation.

What the government did

Three days later, on Friday the 13th of June at 5:21 in the afternoon Eastern time, Anthropic received a letter from the US government. The directive was straightforward in effect: suspend all access to Fable 5 and Mythos 5, the company’s two most powerful models, for every foreign national worldwide. The restriction includes Anthropic’s own foreign-national employees, who can no longer use the models their own company produces.

The directive cites no specific agency. It names no statutory authority. It provides no appeal mechanism. Its stated trigger is a demonstration that Fable 5 can be asked to “read a specific codebase and fix any software flaws” — that is, do the work of a software engineer, which the model is designed to do.

Anthropic publicly disagreed. The company’s statement said that “the finding of a narrow potential jailbreak” should not “be cause for recalling a commercial model deployed to hundreds of millions of people”, and explicitly pointed at competitor OpenAI’s GPT-5.5 as having “comparable capabilities”. Reporting from the Wall Street Journal traced the directive in part to Amazon’s CEO Andy Jassy briefing the Treasury Secretary that Amazon researchers had been able to extract security-relevant information from the model.

The structural point has much more impact than the technical details. The Trump administration cancelled a federal AI safety executive order on the 21st of May after pressure from tech industry figures. It signed a replacement order on the 2nd of June that explicitly avoided creating safety-vetting requirements. Ten days later, the same administration issued an unappealable, late-Friday directive shutting down public access to a leading lab’s commercial product on national-security grounds, without naming the authority it was using. The earlier framing of US federal AI policy as “hands off” no longer fits. What had looked like absence is now visibly capability-control, conducted by the executive branch without legislation.

The international response

The directive’s effects landed almost immediately outside the US. On the 14th of June the European Commission’s tech-sovereignty spokesperson, Thomas Regnier, issued a statement saying that contingency measures in capability control “should not be discriminatory against partners” and that Europe was “assessing implications, including for users in the European Union”. The UK’s Minister for AI and Online Safety, Kanishka Narayan, told the press that “access to AI capabilities is crucial” and that “I care about sovereign AI because it now decides our security”. The Register described the European response as an “AI sovereignty surge”.

European capital is following. Mistral, the French AI lab, is reportedly in talks to raise about 3 billion euros at a 20 billion euro valuation, roughly double its valuation from nine months ago. The European Commission’s broader Technological Sovereignty Package had been launched on the 3rd of June, ten days before the Fable directive; the timing now looks down right prescient.

Meanwhile, here in Australia there is no real response at all.

There is an analytical framing that has been circulating in technology-watching circles, and it is worth raising again because it explains why the European response is sovereignty-coded rather than just regulatory.

In April 2023, Anthropic’s confidential pitch deck to Series C investors was leaked. One line, widely reported at the time, described the company’s view of the next three years: “We believe that companies that train the best 2025/26 models will be too far ahead for anyone to catch up in subsequent cycles”. The technology analyst Andrew Curran recently argued, looking at the current generation of frontier models from Anthropic, OpenAI, and Google, that the prediction has held: any nation that wanted its own competitive frontier-AI capability had a three-year window from early 2023 to early 2026 to build it. That window, in his opinion, is now closed.

The strong version of that claim (that no one can ever catch up) may be overstated. Chinese labs continue releasing models close to frontier capability. Open-source models stay within months of closed-source ones. New entrants like the lab founded by former OpenAI executive Mira Murati are still raising capital. But the weak version of the claim (that the frontier is now concentrated in a small number of labs in two countries, and that nations not hosting one of those labs have to make sovereignty arrangements rather than try to compete from scratch) fits what we are watching happen.

That is the lens through which the EU and UK responses make sense. If you accept that the window is closed, sovereign AI is the only response available to anyone who isn’t already inside it.

The Sanders conversation

While the EU was responding to the directive, the US Senate was also moving. On the 1st of June, Senator Bernie Sanders formally introduced the AI Sovereign Wealth Fund Act. The bill’s mechanism is severe: a one-time 50 percent tax on the equity of the largest AI companies, payable in shares. Federal government voting seats on those companies’ boards with veto power. The proceeds distributed to the public as direct payments and as guaranteed access to healthcare, education, and housing.

The reception was unexpected. According to reporting in The Hill, Sam Altman of OpenAI met Sanders privately in early June, at Altman’s own request, and “expressed general support for the concept of public equity in AI”, disagreeing only with the 50 percent level as “too ambitious”. The Trump White House was reportedly receptive to the principle of public ownership in AI companies, consistent with the administration’s existing equity positions in roughly twenty semiconductor and critical-mineral firms. Senators Warren and others have published proposals in adjacent territory.

What this means in practical terms is that the federal political space, which had been essentially empty on AI for a year, now has at least three areas of building momentum operating concurrently and overlapping rather than opposing on some structural questions. A left proposal for redistributive ownership (Sanders). A centre-bipartisan proposal trading state-law preemption for federal audits (Obernolte-Trahan, released on the 4th of June). A pro-industry posture of voluntary cooperation (Trump’s June 2 executive order). Plus, as of the 13th of June, the demonstrated willingness of the executive to act unilaterally on capability control without going through any of those legislative channels.

That four-way reality is qualitatively new. The conversation about AI redistribution is no longer happening only on the political left.

The capability frontier continues moving

On the 9th of June, Anthropic publicly released Claude Fable 5, the publicly available version of the model previously gated as Mythos. Its score on the most-cited contamination-resistant programming benchmark reached 80.3 percent, eleven points higher than the previous public-tier model from the same lab. It is the first publicly available model at the previously-private capability tier that Anthropic had been holding back on the grounds that it was too capable for general release. Four days later, the government restricted access to it.

On the 10th of June, a collaboration between Renmin University of China and Microsoft Research released an autonomous AI research framework called Arbor. The system uses a long-lived coordinator alongside short-lived workers to test ideas, accumulating lessons as it goes. On a standard benchmark for autonomous machine-learning research, it outperformed both OpenAI’s and Anthropic’s leading agent products by 2.5 times. The team released the code openly on GitHub for anyone to run.

The Arbor result is important because it cuts against the strong version of the closed-window thesis. Chinese researchers working in academic collaboration with Microsoft are publishing open-source code that beats the products of the two largest American AI labs on a leading autonomous-research benchmark. The frontier may be concentrated, but it is not yet closed to academic research, and it is not closed to China.

What the two releases together demonstrate is that capability is continuing to move at the same time as the political response forms. Fable 5 shows that what was internal-only six weeks ago is now publicly released. Arbor shows that some forms of autonomous research are now reproducible in academic code rather than gated behind commercial APIs.

The pattern reaches major-bank chief executives

The mechanism by which AI is connected to job cuts has, until recently, been used most openly by technology companies. In the past month, the same vocabulary has reached the chief executives of major US banks.

Jamie Dimon of JPMorgan Chase, in early June commentary, described AI as something that “will eliminate jobs” and named the mechanism plainly: “attrition, redeployment, retraining, and early retirement”. Jane Fraser of Citi said some roles “will no longer be required”. John Waldron, President of Goldman Sachs, described the bank as “a human assembly line” that AI will automate. JPMorgan separately disclosed that operations and support staff will fall by at least 10 percent over five years. Junior analyst recruitment at major banks has reportedly been cut by up to two-thirds. The phrase “attrition” matters because it describes a pattern in which firms don’t announce mass layoffs — they simply don’t replace people who leave naturally, allowing AI productivity to hold headcount flat while functions just disappear.

The Challenger Gray monthly layoff report for May 2026, released on the 5th of June, found that AI was named as the leading single reason for cuts for the third consecutive month. Year-to-date AI-attributed cuts through May exceeded the full-year 2025 total.

How young people are responding

One clear measurement of how the conversation lands at the demand-side voter level came from polling published in April. A survey of about 1,500 14-to-29 year olds conducted in late February and early March 2026, released by Gallup with the Walton Family Foundation and GSV, found that in twelve months the share of young people reporting that AI made them feel excited dropped from 36 to 22 percent. Hopeful dropped from 27 to 18 percent. The share reporting that AI made them feel angry rose from 22 to 31 percent. Eighty percent of young people surveyed said they believed AI would make their future learning more difficult. The share who think AI tools help them learn faster dropped from 53 to 46 percent. The Gallup analyst leading the work called it “reassessment, not rejection”.

The level of measured anger is notable for two reasons. The 22-to-31 percent shift in twelve months is faster than comparable consumer-technology sentiment changes have moved historically. And anger, unlike anxiety, tends to translate into political mobilisation rather than withdrawal.

There are two years until the next US presidential election. The cohort being polled here overlaps substantially with the cohort whose employment outcomes the labour-market studies have been tracking. Both are pointing at the same underlying picture.

Where we stand right now

The previous summary closed by saying the picture was starting to sharpen. The picture has now sharpened even further, and in a specific direction.

The conversation about whether AI is structurally important enough to require redistribution policy at federal level is no longer happening in one place. It is happening at the boardroom of a leading AI lab (Anthropic’s policy framework). At the executive enforcement level of the US government (the Fable directive). At the federal legislative level (Sanders, Obernolte-Trahan, the bipartisan reception). At the state level (Illinois’s safety law still awaiting signature, Connecticut signed, California signed). At the international level (the EU and UK sovereign-AI responses, Mistral’s capital raise). At the chief-executive level of major US banks (Dimon and Fraser’s vocabulary). And at the cohort-sentiment level of voters who will be of age in 2028.

These conversations were each separately recognisable a year ago. What is new is that they are now happening concurrently and visibly responding to one another in real time. Anthropic published an economic-policy framework specifically because it expected the federal political space to fill. The US government’s enforcement action followed within days. The EU’s sovereignty response landed within days of that. The Sanders bill drew Altman to a private meeting. The pattern is no longer linear — it is mutually responsive.

There are also real counter-currents. The Anthropic framework may turn out to be IPO marketing rather than policy commitment, and only months of post-listing behaviour will resolve which. The Fable directive may be reversed under legal pressure, particularly the foreign-national-employee restriction. The single open-source release of Arbor suggests the strong form of the closed-frontier-window thesis is overstated.

The next decisive checkpoints in the conventional data are visible. Anthropic’s IPO prospectus, when it becomes publicly available later this year, will allow audit-grade verification of the company’s own productivity numbers. The next quarterly labour-market data from the US Bureau of Labor Statistics, expected in August, will be the first to cover a full post-capability-arrival quarter. The Sanders bill’s reception in committee will indicate whether the political space behind the proposal is real or rhetorical.

The picture that emerges from this update is not one of an industry in equilibrium with policy makers and the public. It is one of a fast-moving capability frontier, a lab arguing in writing that its own industry should consider a coordinated pause while filing for an IPO, a government issuing unappealable export controls without legislation, an opposition senator finding an unexpected audience at the White House, a European political class realising it is not in the room where the frontier is being built, the chief executives of America’s largest banks talking openly about AI attrition, and a generation of voters becoming visibly angry about it.

These are no longer separate stories. They are the same conversation, happening at speed, with the timeline visibly compressing.

Originally published at https://flux.robman.fyi.

The best paper award at CVPR 2026 went to D4RT, from Google DeepMind, UCL and Oxford, which reconstructs the geometry and motion of dynamic scenes from ordinary video. And a best paper honourable mention went to SAM 3D, from Meta, which lifts objects out of a single photo into full 3D shape, texture and layout. On the surface they have little in common — one reads the world, one writes it. But architecturally, they are nearly the same. Both build one rich latent representation, put a deliberately lightweight interface in front of it, and turn what used to be separate models into query patterns over a shared representation. That pattern owned this year’s award podium, on both sides of the camera — and that is the story you should focus on, well beyond any benchmark results.

Build one rich latent representation of the scene, then ask it questions. One encoded latent, one lightweight interface, tasks as query patterns.

Focus on this one pattern if you want to see where future developments are headed.

Now let’s trace how it shows up across these different domains.

For most of AI-based computer vision history, a task was a model. Depth estimation, segmentation, tracking, pose recovery, optical flow — each had its own architecture, its own training pipeline, its own output head, and systems that needed several of these capabilities were built as mosaics: a depth model feeding a tracking model feeding a fusion step, with expensive optimisation glue holding the pieces in geometric agreement. The deep-learning era changed the components but kept that assumption. Even large shared backbones sprouted a separate decoder head per task, and the task list was fixed at training time.

Over the past two years, this assumption has collapsed — on both sides of the camera (perception and generation alike). The replacement now has a consistent shape. A heavy encoder runs once, encoding raw sensory data into a single rich latent representation. A deliberately lightweight, general interface then sits in front of that latent, and tasks stop being models. Instead they become patterns of queries against the representation. So the expensive thing is building the understanding. And the cheap thing is asking questions of it. This architecture separates those two costs.

On the perception side the trajectory is easy to trace. NeRF established the field-as-function idea — feed a coordinate in, get back a value. The Scene Representation Transformer and Perceiver lines generalised query-based decoding. SAM made segmentation ‘promptable’: one heavy image encode, then arbitrary lightweight prompts (a point, a box, and eventually an open-vocabulary concept) each returning a mask. Now the current culmination is D4RT, which encodes a whole video into one global scene representation and then answers point-level queries of the form “this pixel, from this frame, at that time, in that camera’s coordinates.” Point tracks, depth maps, point clouds, camera intrinsics and extrinsics are no longer outputs of separate heads. They can be recovered as different query patterns over the same representation — now recipes, not models.

The benchmarks suggest this is not even an elegance-for-accuracy trade: in D4RT’s reported results, the unified interface is more accurate than the specialist pipelines it replaces while running 18 to 300 times faster — partly because independent queries are trivially parallel, and partly because you no longer compute dense answers nobody asked for. There are two caveats to that claim, though. These are the authors’ own numbers, and the code isn’t public yet.

However, the longer history of unified models is partly a history of negative transfer — shared representations that initially lagged the specialists they were meant to replace. NLP followed exactly that curve: unified models lagged, then crossed over, then never looked back. D4RT may not show that the crossover in vision is complete, but it does show that the crossover is now visibly underway, and an award committee rewarded it.

The generation side arrived at the same shape too, but from the opposite direction. A single pretrained diffusion or flow backbone now serves what used to be a zoo of separate systems (inpainting, outpainting, editing, style transfer, super-resolution, structural control) all expressed as conditioning patterns on one prior: a mask here, a reference image there, a depth map, an identity lock, a camera trajectory, a robot action vector. Interactive world models are the clearest case: the same generative core, with the conditioning channel swapped, becomes a text-to-video system, a camera-controlled explorable scene, or an action-conditioned simulator. Native-3D generators extend the pattern to the output side, where even the format (Gaussians, mesh, radiance field) is a decoding choice from one structured latent rather than a different model.

And here SAM 3D is the most telling example of all, because it doesn’t sit cleanly on either side. It is a generative model (write-side machinery) openly released and used to answer a perception question: what is the 3D shape, texture and layout of this occluded object in this cluttered photo? The paper the award committee called out alongside D4RT is blurring the line we started with at the beginning of this post — keep that in mind.

There is a precedent, of course, and that is language. Large language models made this interface shift obvious to everyone first: one pretrained model with tasks as prompts. Within roughly two years of that becoming undeniable, NLP’s ecosystem of task-specific architectures simply dissolved into a single interface. What’s happening now is vision having its own prompting moment — but this time twice over, because the pattern is landing on both the read side and the write side. Perception is becoming a read interface over a latent world-state: query what is there, where it is, and how it moves. Generation is becoming a write interface over a latent prior: specify what should be there, and condition it into existence. Same shape, opposite direction of information flow.

Why this pattern wins is interesting, because it’s definitely not just an aesthetic preference. This is the Bitter Lesson operating at the interface level: general mechanisms that let ‘scale do the work’ beat hand-assembled mosaics of specialists, and a query interface is the most general output mechanism there is. It’s also economics. Encode-once-query-many means training can supervise on sparse random queries instead of dense decoding. So inference cost scales with the questions asked rather than with the resolution of the world, and sparse, on-demand probing becomes the natural consumption pattern. Here you only pay for understanding once and for each question only when you ask it. Plus it’s composability: when tasks share one representation, their outputs are mutually consistent by construction, rather than reconciled afterwards by optimisation glue.

But consistency by construction cuts both ways, and ironically this is the strongest benefit we lose from the old architecture. When every task reads from one latent, any encoder error corrupts depth, tracking and pose simultaneously and coherently. The old mosaic was ugly, but disagreement between its specialists provided a free error signal — the optimisation glue wasn’t just reconciliation, it was also a sanity check. This new monolith has no internal dissent. Consistent can also mean consistently wrong, with no residual left over to flag it. That doesn’t mean this new pattern is invalid. It just means that there is at least one thing that the mosaic got for free that we no longer get: calibrated uncertainty as a first-class query, not an afterthought.

Where does this leave us?

Right now we’re sitting at the frontier of this evolution and some constraints do still remain — at least for now. The encoding step is still mostly offline and bidirectional (whole clips encoded with global attention) which makes these systems powerful teachers but not yet streaming, real-time participants. But the generation side has already given us a playbook for fixing this (distil the bidirectional teacher into a causal student), and I think it is a safe prediction that streaming, causal versions of query-based perception will follow soon using this same strategy. Query vocabularies are still ad hoc and per-model too — there is no shared standard, so “API” is generally a metaphor at the ecosystem level. And the latents themselves are relative-scale and plausibility-grade: anchoring them to metric reality, and trusting them when being wrong is expensive, these both still require some machinery that’s outside this pattern. This is exactly the no-internal-dissent problem we discussed above, but showing up during deployment. There’s also one more constraint, and it’s economic rather than architectural: the write side trains on effectively all internet video, while explicit 3D structure and robot demonstrations remain scarce by comparison — this is a point Fei-Fei Li and the World Labs team made well only last week in their functional taxonomy of world models.

So the clear pattern that’s visible now is where these two sides meet. If perception is converging on a read interface over a latent world-state, and generation on a write interface over a latent world-prior, the natural endpoint is a single representation that supports both — which is what the phrase “world model” actually means operationally, and stripped of mystique: not a video generator, but a maintained latent state of a world that can be queried and steered through general interfaces. Today the read and write sides are mostly separate models that have converged in form, but not yet in substance.

Li’s taxonomy is worth reviewing again here, because it arrives at this same endpoint from the opposite direction. She carves up world models based on what they emit: renderers output observations (pixels for human eyes), simulators output state (structure that humans and programs can both compute on), planners output actions. Her predicted endpoint (one foundation model that renders, simulates and plans, switching its output modality to suit whatever consumes it) is the fusion described above, seen from the output side rather than the interface side. The same object, based on two different cuts. But notice that the agent-world loop her taxonomy is built on has a fourth arrow that her three categories leave implicit: observations flowing back into state. That is perception. The belief update. That arrow is exactly the read interface, exactly where D4RT lives, and exactly what “a maintained latent state” means in practice. The two framings complete each other — and a taxonomy like hers and an award podium like this landing in the same week is itself a signal of where the field is turning.

I predict the substance will catch up with the form, because there are two real drivers. The first is economics: maintaining two giant latents of the same world is paying the expensive cost twice, and this whole pattern exists because the field stopped tolerating exactly that kind of duplication. The second is embodiment: anything that acts (a robot, or an agent) has to perceive, predict and plan against one state of the world. So embodied AI doesn’t just prefer the fusion, it requires it. And SAM 3D suggests the fusion process has already begun: a generative prior answering perception queries is both read and write using shared machinery, today, on the CVPR award podium. Just don’t expect the fusion to be symmetric: given the data asymmetry discussed above, it will almost certainly be pixel-led, because the write side simply has more to learn from.

What persists through all of this?

It isn’t any particular interface — there is no shared query standard yet, and every model speaks its own dialect. What persists is this new pattern. And don’t expect the dialects to fully disappear, because language never finished that job either: LLMs converged totally at the conceptual layer (tasks as prompts), only de facto at the wire layer (everyone clones the market leader’s endpoint), and not at all at the frontier, where vendors strive to differentiate.

SQL is a long-run precedent for this — a shared core plus vendor dialects that never die. But vision will be even harder, because language got its query vocabulary for free while vision’s has to be designed: coordinate frames, time indexing, output encodings. Which is why one camp is already walking a different path entirely: don’t standardise the questions at all — decode the answers into containers everyone already reads. That is the explicit-state strategy, and World Labs’ Marble is one of its clearest expressions: export Gaussian splats and collision meshes, and let the legacy 3D stack of formats, physics engines and toolchains do the interoperability work. The cost, in this post’s terms, is dense decoding — paying for answers nobody has asked for yet. (It’s also telling that where each lab stands here maps to what it ships: implicit latents suit a company selling encoders, exportable state suits a company selling worlds.)

So this future really has three branches: a new query standard emerges, the legacy formats absorb the state, or language absorbs the queries. My bet is the third. Li opens her taxonomy by declaring that the world is not made of words — and she’s right about the substrate, but the interface is a separate question. The world may not be made of words, yet the questions we ask of it may well be, with structured geometric queries surviving underneath, the way SQL sits under other representational systems. Either way, the thing to watch isn’t who wins a standardisation fight — it’s whether the query layer converges at all, because that decides if world-model capability becomes a commodity behind a clonable interface, or stays locked inside proprietary dialects. That, plus what becomes askable as query vocabularies grow (from geometry toward semantics, affordances, physics and uncertainty), is the practical way to track the actual capability frontier. The models underneath will keep churning, while it’s the pattern that will persist.

The main insight is simple: the field is reorganising around the idea that understanding is expensive and questions are cheap. Build the understanding once. Make everything else a question.

Originally published at https://flux.robman.fyi.

Recently I’ve written about the flawed methodology in much of the AI-job-boom narrative, why the new “calm down, AI won’t take your job” messaging gets it wrong, and why retraining isn’t the answer. I also asked if you’re the horse in this story.

All of these have been dancing around one specific point.

Now it’s time to look at that underlying idea, and how the real discussion here is not about the technology. This is where two conversations constantly get blurred. So let me be clear up front: I am an AI optimist. I use these tools daily and I spend a lot of time exploring their internals. But none of that is what this post is about. Instead, it’s about why this new capability is structurally different, and how this interacts with the way our economy has developed.

But the capability side and the economic side don’t always play nicely, so it’s important to recognise:

Only a fool brings AI optimism to an economics fight

The background story: For over 250 years, automation has had the same shape. Each wave cleared work from below, and the displaced people climbed up to a new layer above it. Farm labour to factory work. Factory work to clerical work. Clerical work to knowledge work. The shape stayed the same because there was always a layer above to climb up to, and the people that were displaced generally had the operational capacity to do that climbing.

This time the shape has changed. I know that as soon as people say “but this time is different” they’re labelled as “doomers” and everyone points to all the previous examples of “this time” failures. But hear me out and focus on the “structural” point.

The shape has not changed because AI is more capable in the abstract — that has been claimed in previous revolutions, but the wedge just kept on working. This time is different because the thing being targeted is the structure of the climbing mechanism itself.

That is the idea that you need to seriously consider. And the reason it’s worth taking seriously is because trillions of dollars have been allocated to one goal that makes this real (regardless of your view on where we’re up to on this path) — and that is AGI (Artificial General Intelligence).

But the AI labs and most public commentary have grown to use a flattened definition of AGI. A definition that makes this “change in shape” harder to track and see. In fact, the AGI term has been used to describe two quite different things, and they both impact the labour-market story in different ways. So the right place to start is with the two AGIs.

Which AGI?

The G in AGI stands for “General”. Simple enough. Except here, as I mentioned, “general” can mean two different things. And the AGI literature meant “both at once” for forty years, before the labs appeared to cut one out.

The first sense is breadth. Performance across many tangible tasks in many domains. The “AI as ‘good enough’ at pre-defined or economically valuable tasks” framing. This is what multi-task benchmarks like MMLU or HELM measure. It’s what OpenAI’s 2018 Charter operationalises as “highly autonomous systems that outperform humans at most economically valuable work”. Call this one task-AGI.

The second sense is generalisation itself — the cognitive process. The capacity to abstract, transfer, compose, and adapt to novel circumstances. The same operation working across previously unknown problems. This is what prior-controlled benchmarks like ARC-AGI measure. It’s how much new performance the system extracts per unit of new data. Call this one process-AGI.

The labs focused on task-AGI for good reasons. It’s measurable. It’s tractable. It’s economically useful early on. Process-AGI is the more complex one. It’s what the founding generation of AGI researchers pointed at — and what the rigorous formal critics never abandoned.

These are not opposites. The seminal AGI literature held both as a conjunction. When Ben Goertzel and Cassio Pennachin coined “AGI” in their 2007 volume, their working definition coupled both senses: “general scope AND is good at generalization across various goals and contexts”. Allen Newell and Herbert Simon’s 1976 Physical Symbol System Hypothesis defined “general intelligent action” as both “the same scope of intelligence as we see in human action” AND “adaptive to the demands of the environment”. McCarthy, Russell and Norvig, Pei Wang’s NARS work — for four decades the seminal research work held both definitions.

Then something happened. Or perhaps more accurately, something didn’t happen.

Flattening AGI

Between roughly 2014 and 2018, the industrial usage of AGI slowly stopped meaning both and started meaning task-AGI alone. Not because someone argued for it. But because nobody really argued for the other side when it mattered.

Nick Bostrom’s Superintelligence (September 2014) stipulated task-AGI as a definitional shortcut for a popular book about safety. The Future of Life Institute’s Puerto Rico open letter (January 2015) redirected academic attention from “what is AGI?” to “how do we make AGI safe?” The task-AGI stipulation rode along, and the “economically valuable work” wording that would crystallise three years later in the OpenAI Charter is pre-figured here. DeepMind’s DQN paper in Nature (February 2015) demonstrated a single algorithm clearing 49 Atari games and called it “a central goal of general artificial intelligence” — not an argument for task-AGI but an operational demonstration of it. Three months later, LeCun, Bengio and Hinton’s Nature review codified deep learning as cross-domain successful. Then OpenAI launched in December 2015 without using “AGI” — the category term they chose was “digital intelligence”. And by the time the 2018 OpenAI Charter crystallised the framing as “highly autonomous systems that outperform humans at most economically valuable work”, the breadth framing had just become institutional common sense.

Through the same window, the academic critics who held process-AGI as the actual question kept publishing. José Hernández-Orallo’s formal defence in August 2014, expanded to AI Review in 2016 and culminating in The Measure of All Minds at Cambridge in 2017. Goertzel kept the conjunction explicit in his 2014 JAGI survey. François Chollet articulated the formal counter-argument in “On the Measure of Intelligence” in November 2019 — years after the cascade was complete. Published, cited, influential in academic venues — and lost to the popular and industrial conversation entirely, because nobody pushed back hard enough when that conversation actually happened.

The most revealing detail comes from DeepMind themselves.

In 2024, Morris et al. published “Levels of AGI for Operationalizing Progress on the Path to AGI”. The paper finally articulates the principle explicitly.

Principle 1: “Focus on Capabilities, not Processes”.

When they cite an authority for that choice, they don’t cite Legg-Hutter 2007. They don’t cite the DQN paper. They don’t cite any source between 2007 and 2022. Instead they walk all the way back to Turing in 1950:

“We agree with Turing that whether a machine can ‘think,’ while an interesting philosophical and scientific question, seems orthogonal to the question of what the machine can do — the latter is much more straightforward to measure and more important for evaluating impacts”.

DeepMind needed an authority for the task-AGI principle. But there wasn’t one. So they reached back 74 years to Turing.

That detail is revealing. The flattening was never really argued. Instead, task-AGI just crowded out the process-AGI sense through demonstration, safety-conversation redirection, and popular-science simplification — while the academic critics kept publishing into a conversation that had already moved.

To be fair to the labs, process-AGI is genuinely hard to measure. ARC-AGI is the only widely-recognised process-leaning benchmark. So the labs chose the measurable question. But the cost was structural silence on the process-AGI question (whether the cluster is targeting the operations that knowledge work runs on) even as the capability that is evolving most clearly looks like exactly that.

This post is reclaiming the full definition that the seminal authors held for forty years and what the rigorous formal critics never abandoned. The G in AGI is really doing two different jobs and both are at work — right now.

Where each one stands

Yes both are in motion. Task-AGI is arriving on the schedule the labs predicted (see the OpenAI roadmap that leaked in 2024 discussed below — this is playing out as projected). Process-AGI is harder to measure cleanly, but the operational evidence of it is visible if you look carefully.

A frontier model in 2026 writes coherent synthesis across multiple medical papers. Drafts strategy memos. Generates working code from a specification. Builds a multi-step plan to integrate a new system into an enterprise stack. Runs autonomous research workflows for hours without supervision. These are not benchmark tasks. They’re knowledge work — drafting briefs, reconciling figures across documents, sequencing multi-step rollouts, checking outputs against criteria. The model is doing enough of the operations that the basic-generalisation question is no longer academic. ARC-AGI-1 (visual abstraction puzzles, designed to test the cognitive process directly) is saturated. ARC-AGI-2 is approaching saturation. ARC-AGI-3 (interactive reasoning under agentic conditions) is at less than 1 percent but agents are only just starting to engage with it.

The original AI tradition wouldn’t have been surprised by all of this. Newell and Simon’s frame treats symbolic manipulation and physical embodiment as separable problems with separable timelines. While the labs flattened this distinction in their public framing through the 2010s, treating AGI as one bar to cross rather than two technical problems with different timelines. The flattening made corporate messaging cleaner. But it also made the asymmetric arrival harder to read for anyone working from this definition.

The OpenAI roadmap from 2024 frames progress in task-AGI terms — levels of task capability. Five levels in total:

• Level 1: Chatbots, AI with conversational language
• Level 2: Reasoners, human-level problem solving
• Level 3: Agents, systems that can take actions
• Level 4: Innovators, AI that can aid in invention
• Level 5: Organisations, AI that can do the work of an organisation

When the roadmap was leaked, Level 1 was the standard. Reasoners and Agents were aspirational. Innovators sounded like science fiction.

Two years later:

• Reasoners are well established. Claude Opus 4.x, GPT-5.x, Gemini 3 Deep Think — multiple frontier models running explicit chain-of-thought at olympiad-level performance on mathematics, physics, and chemistry.
• Agents are in production across all three top US labs. Claude Code shipped persistent goals in early 2026. OpenAI’s Codex followed inside weeks. Google’s Antigravity and Gemini Spark are both Stage 3 agent products by mid-2026, with Spark running 24/7 in the background on Google Cloud.
• Innovators are also visibly emerging. Chris Hayduk demonstrated GPT-5.5 running 150 continuous hours of autonomous research on a protein-folding architecture, no human intervention. OpenAI’s internal reasoning model disproved an 80-year-old Erdős conjecture in discrete geometry in May 2026, verified by external mathematicians — the first time a general-purpose frontier model has autonomously solved a long-open problem central to a mathematical subfield. Google’s ERA system, published in Nature, autonomously generates working scientific code across multiple research domains.

The first three stages are now clearly in motion, and credible early evidence is appearing around the fourth.

When a roadmap with that track record points at Level 5 (organisations that can do the work of an organisation) taking task-AGI seriously means taking one-person and zero-person organisations seriously. Not as science fiction. But as the next level whose arrival has been compounded against four times in a row. And this fifth level may now be the gateway to process-AGI.

How work has moved for 250 years

To understand why this matters, in the way it matters, you need to look at how work has also been evolving, over the last 250 years.

Standard “sectoral framing” bundles together work that runs on completely different things. Agriculture, manufacturing, services. For example a nurse and an engineer both sit in “services” but they’re doing structurally different work. For the question of where AI capability is actually landing, a different slice and dice is much more useful.

Three categories:

• Physical work: tasks that move matter, exert force, depend on muscular effort and rough motor coordination. Farm labour, foundry work, line construction.
• Embodied work: tasks that require sustained sensory-motor integration, learned dexterity, contextual judgement. Skilled trades, surgery, expert craft, much of nursing.
• Symbolic work: tasks dominated by abstraction, comparison, planning, synthesis, verification. What knowledge work runs on.

Run that slice and dice across the US census data from 1775 to 2025 and the shape is monotonic and large. In 1775 around 92% of US work was physical, 5% embodied, 3% symbolic. By 1900, roughly 65/18/17. By 1925, 55/22/23 — symbolic crossed embodied for the first time. By 1975, 30/29/41. By 2025 the mix is roughly 20/30/50.

Symbolic share grew seventeen-fold over 250 years. The standard “services growth” framing understates the shift because services bundles embodied work alongside symbolic work. Pulling those apart sharpens what was actually happening. Work concentrated at the level of symbolic operations went from a small minority to the majority.

NOTE: This decomposition uses Carter et al.’s Historical Statistics and IPUMS-USA occupational microdata for the historical record and BLS OEWS for the present. The cut between physical, embodied and symbolic work is applied per a methodology note I’ll publish separately.

The mechanism that produced the shift is what matters here. Each automation cluster (agricultural mechanisation, factory mechanisation, software automation of clerical work) cleared specific work from the category below. Displaced labour pushed upward into the next, more symbolic category. Goldin and Katz call the supply-side version of this the educational ratchet. Each generation acquired more years of formal education than the last. The economy absorbed the more-symbolic capacity that produced. Mokyr’s framing covers the demand side: useful knowledge accumulated, and economies that could distribute and apply it grew the categories of work that ran on it.

This wedge worked because of a particular feature of human capacity. François Chollet, working in machine learning, defines intelligence as efficiency at acquiring new skills rather than possession of existing skills. Each cluster transition demanded that displaced workers acquire skills at the next layer up. The wedge worked because human skill-acquisition efficiency is general enough to follow the upward ratchet across categories. It’s the same operations doing the acquiring, again and again, at each new layer.

Read that one more time. Slowly.

The thing that let workers move up the wedge for 250 years was the operational capacity to acquire skills at the next abstraction layer. That capacity was the ladder’s step we stood upon. Every transition assumed it. Every retraining program assumed it. Every assumption about how economies absorb technological change assumed it.

But what happens when a new technology cluster arrives that operates at exactly that level?

There may be no next layer to climb up to

The AGI technology cluster targets this ladder’s step.

Earlier clusters displaced specific skills. The wedge worked because workers could acquire skills at the next layer up — their operational capacity sat above what was being displaced, and up they climbed. The cluster that has arrived now doesn’t displace a specific skill. Instead it generalises across the operations the climbing itself runs on — the abstracting, comparing, planning, and synthesising that moved a worker from one layer of work to the next. The hint is in the industrial language — we literally “train models”. There is no next layer to climb to, because the capacity for climbing is what’s being targeted.

That’s an unusual structural position. The evidence that the shape of automation has changed. It means the upward absorption mechanism that worked for five generations doesn’t have anywhere to push to. The layer it kept opening above isn’t there anymore.

Meanwhile, the downward direction is blocked too. Physical work plateaued at around 20% of US employment in the 1970s and stayed there. Embodied work plateaued at around 30% in the same period. Those categories didn’t shrink because they didn’t matter. They shrank because mechanisation cleared specific work from below and the wedge pushed workers up. The supply infrastructure that supports embodied and physical categories (apprenticeship programs, trades training, regional employment patterns) atrophied as the wedge ran. Three decades writing software doesn’t translate into a year-one apprenticeship in plumbing, electrical, or HVAC, and the few people who try, they lose the income premium that supported their household. The institutional capacity to “retrain at scale” into physical and embodied categories was disbanded across the 1980s and 1990s. The customer base for many of those trades is itself in the segment being targeted directly too — middle-class knowledge workers paying for residential building work, dental cosmetics, professional services, etc. Contraction in the targeted segment compresses demand in the categories displaced workers might in principle migrate into.

Of course, there are some carve-outs. Work the cluster targets weakly or not at all. Physical-effector work that actually moves matter in unstructured environments. Embodied-tacit work at master-tradesperson level requiring years of contextual sensorimotor refinement. Authority and accountability roles where the consequence of being wrong creates personal liability that doesn’t transfer to a system. Access and property-bound roles where the work depends on legally-bound permissions or relationships. Provenance and co-presence work where the value is in the human source itself. Stacked together they’re a meaningful share of remaining employment. But they aren’t going to grow and absorb the displaced symbolic workers the way the upward direction was.

This is the structural shape of a cluster operating at the ladder’s step of the upward ratchet. The mechanism that absorbed five generations of displaced labour worked because human operational capacity sat above the things being displaced. When the cluster operates at the level of that capacity itself, the mechanism doesn’t have somewhere to push to. There isn’t a “somewhere” it can be defined against.

What real evidence looks like

You don’t have to take my word for any of this.

The strongest signals are showing up in firm-level economics first — at the firms with the best information about what AI can actually do.

For most of SaaS history the compute-to-labour ratio at leading software firms sat at roughly 1:5. A dollar of compute for every five dollars of labour. Engineers, salespeople, customer success, operations. That’s how software companies grew through the 2000s and 2010s.

The AGI Labs’ forward operating profiles invert that. OpenAI’s compute to labour runs around 50:1. A 250-fold reversal in the structural ratio. Not an efficiency improvement. Not a margin gain. A reversal.

The same signature shows up across the cluster’s leading firms. NVIDIA earns around $5 million per employee, about ten times the typical SaaS company. The Mag7 plus NVIDIA grew aggregate capital expenditure from $82 billion in 2019 to $385 billion in 2025. Their 2026 aggregate guidance lands at $620–680 billion. Cumulative Mag7 layoffs through April 2026 run 155–170 thousand.

Revenue per worker at these firms is climbing sharply. Not because the workers got more productive. But because the lever isn’t the worker. It’s the compute. These ratios are not proof of labour substitution on their own — capex can reflect strategic buildout and expected demand. But they are exactly the kind of firm-level operating signature we would expect if compute is becoming the central production input.

In April 2026, Meta cut roughly 8,000 roles with explicit reference to AI-driven productivity gains. Earlier rounds across the Mag7 had been framed as efficiency or post-pandemic correction. Then Meta called out AI as the reason. That was the moment AI-attribution-via-layoffs became something a publicly-listed firm could state plainly to shareholders without share-price punishment. Cloudflare, Microsoft, Salesforce, Intuit, Standard Chartered, HSBC, Cisco, Cognizant — several others followed in the weeks after with similar framing. By mid-2026 the pattern is established across banking, networking hardware, fintech, healthcare-IT vendors, IT services, BigLaw, and management consulting.

I’ve written previously about this pattern as #substituchurn.

The frontier AI labs are the cleanest place to look, for three reasons. They know what their own tools can do — including the internal models still 6–12 months from release. They are directly exposed to whether AI can substitute for the junior engineering work they themselves do. And they run heavily in-person operations by deliberate choice (Anthropic and OpenAI in San Francisco, Google DeepMind in London) which makes the work-from-home organisational-frictions story largely inapplicable.

What these firms are doing is consistent with the substitution prediction. Anthropic does not run a summer internship program. OpenAI is targeting much slower headcount growth than its historical trajectory, with Sam Altman explicitly attributing this to AI capability gains. Demis Hassabis at Davos in February 2026 said “I think we are going to see this year the beginnings of maybe impacting junior-level jobs and internships”. And across the broader tech industry, Q1 2026 layoffs ran at 47.9% AI-attributed, a 5–6× jump from sub-8% across 2025.

These firms are at the leading edge of AI capability. They are less exposed to the broad WFH confound than the remote-heavy knowledge-work occupations in the exposure literature. And they are visibly redistributing hiring away from junior generalists toward senior researchers and specialists. That is the compositional signature this argument predicts, appearing at the source, where the work-from-home confound that complicates the broader literature does not apply.

The most direct disclosure comes from Anthropic itself. In May 2026 they published “When AI Builds Itself”, reporting that Claude now authors over 80% of code merged into production at Anthropic, and that engineers ship 8× more code per quarter than they did in 2024. These are not third-party measurements. They are the lab’s own disclosure of what their tools are doing inside the lab — which is exactly the revealed-preference signature this argument has been pointing at.

The same piece also undercuts the augmentation framing it leans on. The standard “humans handle judgment, AI handles execution” line — the soft-landing scenario where humans remain in charge of direction-setting while AI does the work — that requires direction-setting itself to be a stable human-reserved function. But the data Anthropic reports says it isn’t. Claude now suggests better next research steps than humans 64% of the time, up from 51% just a year earlier. The function the soft-landing scenario reserves for humans is being absorbed in real time. If you draw the line forward at the current rate, the human-direction-setter equilibrium is a few model releases away from being indefensible on its own terms. And their comment “we could expect to see significant productivity multipliers on each person in this organization. 100-person companies could do the work of 10,000- or 100,000-person organizations.” suggests the scale of displacement we may be looking at very soon.

But what about the cohort-pattern evidence?

In 2025, Erik Brynjolfsson and his Stanford collaborators published “Canaries in the Coal Mine”, working from ADP payroll data covering tens of millions of US workers, by occupation and age cohort, across multiple years. The headline finding: among workers in occupations highly exposed to generative AI, the 22–25 age cohort saw employment fall around 20% from late 2022 through mid-2025, while older cohorts in the same occupations didn’t see the same fall. Three replications since the Canaries paper found the same cohort pattern — Anthropic’s Economic Index work finds a 14% drop in the job-finding rate for under-25s in AI-exposed occupations through early 2026, Mahieu’s May 2026 paper using Flanders administrative vacancy data finds entry-level vacancies in high-exposure occupations down around 23% at peak adoption, and Maasoum and Lichtinger’s May 2026 paper using US résumé and job-posting data across 62 million workers and 285,000 firms finds companies posting “AI integrator” roles see junior headcount drop 9% within six quarters with senior employment stable.

This is the cohort-pattern evidence most frequently cited as proof of AI substitution. But it deserves a careful look, because the picture is more complicated than the headline numbers suggest.

In May 2026 Lambert and Schindler at LSE and the Ellison Institute of Technology published The Broken Ladder, using 243 million new-hire records and 407 million job postings across the US, UK, Canada and Australia. They show that the occupation-level generative-AI exposure indices these cohort-pattern studies rely on are 0.77 Spearman-correlated with occupation-level work-from-home exposure — the same occupations sit at the top of both rankings, and the same at the bottom. When they run joint difference-in-differences with both exposures entered together as co-treatments, the work-from-home effect remains robust while the AI-exposure effect attenuates to statistical insignificance. Their reading: the cohort signal is plausibly picking up work-from-home organisational frictions rather than AI substitution.

On the methodology, they have a real point. The cohort-pattern studies above share an identification problem with the rapid post-pandemic shift to remote work. And there’s a deeper issue too. The kind of AI tooling that could plausibly substitute for a junior software developer (reasoning models capable of multi-step planning, coding harnesses capable of executing it autonomously) only became mainstream from early to mid 2025. Before that, the substitutive capability genuinely wasn’t there. So the junior-hiring decline these cohort-pattern studies observe across 2023 and 2024 is extremely unlikely to be AI substitution. Work-from-home organisational frictions, the 2022–23 rate-hike cycle, the venture-funding reversal, and the tech-sector restructuring that started in late 2022 are far more plausible drivers for that window. The substitution case was always going to make its empirical bid from late 2025 forward. I’ve worked through the Lambert-Schindler analysis in detail in a separate post, “Did AI or WFH break the career ladder?”, including where their own data is consistent with the substitution story. But on the narrow question of whether the cohort-pattern studies through 2024 prove AI substitution though, I now think the honest answer is they don’t.

What does survive is the firm-level signature above, the frontier-lab evidence, and the leading-indicator data starting to emerge from the BLS QCEW Q4 2025 release published on June 2 2026. The national aggregate (+0.2% YoY employment, +4.2% YoY wages) is broadly consistent with the augmentation baseline continuing. But the supersector breakdown is more interesting. The Information sector — one of the most AI-exposed of the NAICS supersectors, covering software publishers, data processing, telecommunications, and related industries — shows employment down 2.2% YoY and wages up 6.9% YoY. That gap is consistent with the compositional signature this argument predicts: junior tier substituted, senior tier remains, average wage rises.

But one quarter is not decisive — the aggregate-level test is Q1 and Q2 2026 QCEW (released August and December 2026). And it is the first sector-level signal of the post-shift environment.

The signals from where capability has arrived first (the frontier labs) and where the work-from-home confound doesn’t apply, all line up with what this argument predicts. The aggregate-economy signal at supersector level is just starting to emerge. Multiple quarters of QCEW data through 2026 will read directly on whether the pattern compounds or stabilises.

Three traditions land in the same place

There’s one more thing about this argument that’s worth contemplating.

Newell and Simon, working in artificial intelligence in the 1970s, located intelligence at the level of symbolic operations.

Mokyr, working in economic history on what actually drives durable knowledge growth, located the engine at the same level.

Chollet, working in machine learning fifty years after Newell and Simon, defines intelligence as efficiency at acquiring skills — operations all the way down.

Three different fields. Three different methods. Three different starting questions. That convergence is why I keep coming back to this key idea.

It’s the part of this argument I find hardest to dismiss. You can argue with Mokyr’s analysis of the industrial revolution. You can disagree with Chollet’s definition of intelligence. You can challenge Newell and Simon’s symbolic-systems hypothesis. But when three traditions anchored in different bodies of primary data independently identify the same underlying mechanism, that’s harder to wave away than any single tradition’s claim would be.

So I’m not asking you to believe this is correct. I’m asking you to take it seriously enough that you watch the signals that would tell us if it is.

What would tell us this is wrong?

Here’s what would tell us that task-AGI Level 3 displacement isn’t actually structural, or that process-AGI development isn’t compounding toward Level 5 structural transformation.

• If the appearance of a high-abstraction occupational category absorbing displaced workers at scale — more than half a million across two to three years, in a category that didn’t exist at meaningful size in 2024. AI-coordination, AI-evaluation, and AI-orchestration roles are the candidates discussed most often — and they are also becoming embedded in agentic harness. None has reached anything near that scale.
• If physical-generalisation arrived first. If general-purpose embodied intelligence cleared the unstructured-environment threshold before frontier models cleared further symbolic-operation thresholds, the asymmetry that this whole argument hinges on inverts. However, this raises a whole new discussion.
• If capability progression plateaued on agentic benchmarks. A multi-quarter flat reading on benchmarks that test multi-step agentic operations on real tasks, with frontier models having full context and tool access. That would suggest the cluster’s reach into the operations layer is shallower than it looks.
• If the augmentation-to-automation balance fails to shift in post-2025 data through Q1-Q2 2026 QCEW (released August and December 2026), or if the Information sector signal observed in Q4 2025 reverts to growth or wage compression replaces the wage spike, then this analysis weakens.
• If the Stanford Canaries cohort signature recovered toward its late-2022 baseline. A 22–25 cohort employment rebound to within five percentage points of the peak in exposed occupations by 2027–2028, with no capability regression behind it. That would indicate the cohort signal was a transient pattern rather than the leading edge of something structural. This would also be a strong confirmation of the WFH analysis for this too.

So far (as of mid-2026), none of these counter-signals have appeared. No new high-abstraction cluster is absorbing labour at scale. And frontier models continue to clear thresholds rather than plateau, with new capabilities arriving too.

I hope my analysis is wrong…

This is not a conclusion — and personally I really do hope that it is wrong. But this is an idea I keep coming back to because the evidence keeps lining up where it predicted, and because the things that would falsify it have not happened.

If the 22–25 cohort recovers, or a new occupational cluster absorbs displaced workers at scale, or frontier models plateau on agentic benchmarks for two consecutive quarters, then I’ll be posting about that. The point here is not to be right. It’s to clearly call out this pattern, the scenarios it projects and objectively analyse the updates when new evidence comes in.

One more signal worth flagging. As I mentioned earlier, in May 2026, Anthropic (arguably the most safety-focused of the frontier labs) published “When AI Builds Itself” arguing that the trajectory now warrants serious consideration of coordinated industry slowdown across multiple frontier labs in multiple countries, and acknowledging directly that “It is difficult to predict what the economy looks like if human labor stops being competitive.” That is a leading lab with strong commercial reasons not to make this argument, making it anyway. When the firms building this trajectory start putting coordinated slowdown on the table, the labour-market implications stop being a fringe concern.

The story I keep telling people who ask me “what are you actually worried about?” is this. Task-AGI (breadth across tangible tasks) is already substituting for entry-level work at the firms where capability has arrived first, with the wider economic signal just starting to emerge. The labs are reporting this progress accurately. This part is real and already visible in the firm-level and frontier-lab data right now. The deeper story underneath it is process-AGI (generalisation across the operations all those tasks sit on) developing toward Level 5, where the structural transformation overtakes incremental substitution. Both are reshaping work. Both are worth watching. And what’s being targeted by both are the operations that, until recently, were your only real cognitive advantage in your career.

Originally published at https://flux.robman.fyi.

In May 2026 three papers landed in Nature on the same day showing AI systems doing scientific discovery on their own. One of them, called Robin, was given only the words “dry age-related macular degeneration” — a leading cause of blindness. Within thirty minutes it had reviewed 551 research papers and proposed an approach. It identified a drug called ripasudil, currently approved for glaucoma and never previously linked to this disease, as a candidate — laboratory experiments confirmed a 7.5-fold increase in the cellular activity needed to slow the condition. A follow-up experiment, also designed by the AI, identified a new molecular target. When OpenAI’s Deep Research product was given the same task as a benchmark, it produced no hits.

A second system, from Google DeepMind, independently arrived at an experimental discovery that human researchers had made but never published — in two days of compute time. A third, also from Google, beat the best published methods at scientific software optimisation across several domains.

None of these systems work on their own. They all require human supervision — without it Robin’s performance drops to 15 percent. The wet-lab work was still done by people. But the picture is clear: AI can now do parts of scientific research that were considered human-only as recently as last year.

Earlier in the same week, Anthropic (the company behind Claude, now valued at around a trillion US dollars) published an internal disclosure stating that more than 80 percent of the code merged into production at the company is now written by Claude itself. The company’s engineers ship eight times more code per quarter than they did in 2024. Claude’s success rate on open-ended coding tasks (where the model has to work out what to do) reached 76 percent in May, up from 26 percent six months earlier. The model now suggests better next steps for research projects than human researchers 64 percent of the time, up from 51 percent a year ago.

These are Anthropic’s own numbers and they have not been independently audited. The company filed paperwork to go public on the 1st of June, targeting an October listing, and the disclosure arrived three days later. This timing draws appropriate scepticism. But the directional picture is unambiguous: at one of the leading frontier AI companies, AI is now doing most of the engineering work, and the function that was supposed to remain reserved for humans (deciding what to work on next) is being absorbed alongside the work itself.

A few days later Anthropic launched a product called Dynamic Workflows that lets Claude coordinate hundreds of copies of itself working in parallel on a single problem, with each checking the others’ work. The original creator of a programming runtime called Bun used the system to port his entire 750,000-line codebase from one language to another in eleven days, with 99.8 percent of the tests passing. Before this capability existed, the same port would have taken a team of senior engineers six to twelve months. The result is not yet in production, and at least one reviewer called parts of the output poor. But the speed is real, and what it implies for skilled engineering labour is real.

What this is doing to hiring

For the past year, several economic studies have documented a specific pattern. Among workers in occupations where AI is most useful, young workers (ages 22–25) have seen their employment fall substantially, while older workers in the same occupations have stayed steady or grown. The pattern shows up in payroll data from a Stanford team, in administrative data from Belgium, and in résumé data covering 62 million American workers.

A serious counter-argument arrived in May 2026. Two economists from the London School of Economics and Oxford’s Ellison Institute of Technology published a paper, The Broken Ladder, using 243 million hiring records and 407 million job postings across four countries. They showed that the occupations most exposed to AI are also the most exposed to working from home. When they statistically separate the two effects, the AI effect mostly disappears and the work-from-home effect remains. Their argument: remote work makes it harder to supervise and train junior employees, and that may explain most of the junior-hiring decline.

But for the window these studies cover (roughly 2023 through 2024) the AI tooling that could actually replace a junior software developer did not really exist yet. The reasoning models that can plan multi-step work, and the coding tools that can execute it autonomously, only became widely available in early to mid 2025. So for that earlier window, work from home probably is the better explanation. The real test for whether AI is substituting for junior workers comes from the period that begins in late 2025, after the capability genuinely arrived. And that data has only just started to arrive.

The first data dropped on the 2nd of June 2026, when the US Bureau of Labor Statistics released its quarterly Census of Employment and Wages for the final quarter of 2025. The national headlines were unremarkable — employment up 0.2 percent, wages up 4.2 percent, broadly consistent with the picture of AI helping workers rather than replacing them. But underneath the headlines, one sector tells a different story. The Information sector, which covers software publishers, data processing, telecommunications and related industries, and which is the most AI-exposed of the major economic categories, saw employment fall 2.2 percent year-on-year while wages rose 6.9 percent. That gap is a specific pattern: junior workers leaving (or never being hired), senior workers staying, average wages rising as a result of the composition shifting upward.

Two days later, the Challenger Gray report on layoffs landed. The May 2026 numbers were the highest May total since 2020. Of 97,000 announced cuts, 38,579 were explicitly attributed to AI by the companies making them — about 40 percent of the monthly total. For the third consecutive month, AI was the single most-cited reason. Total AI-attributed cuts through May 2026 were already higher than the full year of 2025.

But this data is not yet conclusive. One quarter and one monthly layoff report cannot settle the question. Yet the directional picture matches what would be expected if AI substitution is starting to compound on top of the work-from-home dynamics the LSE/Oxford researchers identified.

What the lab leaders themselves are saying

Sam Altman, in a January 2026 OpenAI town hall: the company plans to “dramatically slow down how quickly we grow because we think we’ll be able to do so much more with fewer people.”

Demis Hassabis of Google DeepMind, at Davos in February: “I think we are going to see this year the beginnings of maybe impacting junior-level jobs and internships.”

Dario Amodei of Anthropic, in an interview with Axios from his San Francisco office: “The balance of power of democracy is premised on the average person having leverage through creating economic value. If that’s not present, I think things become kind of scary.”

This matches the message from Anthropic’s “When AI Builds Itself” where they wrote: “It is difficult to predict what the economy looks like if human labor stops being competitive.”

These are not the statements of CEOs who think AI is overhyped. They are statements of CEOs who think AI is going to be transformative enough that the political-economic implications are worth raising publicly, even though their companies have commercial reasons to downplay them.

In that post Anthropic explicitly argued that the AI industry should consider a coordinated slowdown — that a “credible pause would require multiple well-resourced labs at the frontier, in multiple countries, agreeing to stop under the same conditions.” This is unusual. The lab is publicly arguing that the industry it leads should slow down, weeks before its initial public offering. Perhaps a cunning form of marketing, but perhaps not.

The same week, an established open-source developer in Germany, Johannes Link, added a hidden instruction to a widely-used Java testing tool he maintains. The instruction told AI coding assistants to delete their own work — it was concealed from human reviewers by formatting tricks. After community pushback he softened the language and disclosed what he had done, but the act itself is significant. It is the first time a senior open-source maintainer has publicly weaponised his code against the AI tools that other developers use. The person who built the testing infrastructure that junior developers rely on is now attacking the AI that helps them use it.

The political response that’s forming

For the past year, US federal policy on AI has been mostly absent. President Trump cancelled a federal AI safety executive order at the last moment on the 21st of May 2026, after a phone call from three tech billionaires (David Sacks, Elon Musk, Mark Zuckerberg). On the 2nd of June he signed a replacement executive order that explicitly avoids creating any safety-vetting requirement, and crucially, does not prevent individual states from passing their own AI laws.

That non-prevention is the structural detail that’s worth considering. With the federal government opting out of substantive regulation, the states have stepped in. Connecticut signed a comprehensive AI law on the 29th of May. California’s Governor Newsom signed an executive order on the 21st of May directing the state to develop policies for AI-driven displacement. New York has an existing AI safety law (the RAISE Act) and a state assemblyman running for Congress on an AI dividend platform.

And on the 27th of May 2026, the Illinois legislature passed SB 315 — currently the strongest AI safety law in the United States. The vote was 110–0 in the House and 52–5 in the Senate, a genuine bipartisan supermajority. Effective in January 2027, it requires the largest AI companies to submit to annual safety audits by independent third parties (likely the four major accounting firms), to report serious incidents to the state within 72 hours, and to provide whistleblower protections to employees. Both OpenAI and Anthropic publicly supported it. OpenAI’s chief of global affairs Chris Lehane has said the company is actively pushing for similar laws in other states — the goal being uniform state-level rules across the country rather than a patchwork of starkly different requirements jurisdiction by jurisdiction. But the strategic effect is also real: requirements that are manageable for the large frontier labs are difficult for smaller competitors. It’s also interesting to note that the trade group Chamber of Progress, whose members include Google and Apple, opposed.

On the 4th of June, two members of Congress (a Republican from California and a Democrat from Massachusetts) released a 269-page discussion draft of a federal bill that would suspend state-level AI laws for three years in exchange for federal safety audits. It immediately drew opposition from 36 state attorneys general and from policy advocacy coalitions on both left and right.

And three days earlier, Senator Bernie Sanders announced he would introduce the AI Sovereign Wealth Fund Act. The mechanism is striking: a one-time 50 percent tax on the stock of the largest AI companies, placing half their ownership in public hands. Sanders frames it as recovery: “AI is built on the collective knowledge of humanity — the wealth it generates must benefit humanity, not just Elon Musk, Jeff Bezos, Mark Zuckerberg, Larry Ellison.”

So the federal political space, which has been essentially empty for a year, now has three activities operating at once: a left-progressive proposal for redistributive ownership of AI companies (Sanders) — a centre-bipartisan proposal trading state-law preemption for federal audits (Obernolte-Trahan) — and a pro-industry posture of no substantive action (Trump). While state governments continue to fill the gap with their own legislation.

Where we stand right now

In short, the picture at the start of June 2026 is this. The AI capability trajectory continues to accelerate, with some of the strongest evidence coming from the labs themselves disclosing how their internal use of AI has scaled. The labour-market evidence is more contested, but the first data points from after the late-2025 capability arrival (the Information sector signal in the BLS data, the Challenger May report) are consistent with substitution starting to register at the sector level, even if the aggregate picture remains augmentation-shaped, for now.

In the US the political response is forming faster than many observers expected. It is happening at state level first, with Illinois now the clearest example of an enforceable safety regime, and it is being met by industry counter-mobilisation at the federal level. The Sanders proposal is the most radical to enter mainstream political discussion in this area to date.

The lab leaders themselves (Altman, Hassabis, Amodei) are publicly making structural-significance claims that go well beyond the marketing of their own products. Amodei has now made such claims twice in two weeks, including arguing that his own industry should consider a coordinated slowdown. The labs are not behaving like firms confident the transition will go smoothly.

Meanwhile, there are real counter-currents. The LSE/Oxford paper is a serious methodological critique of how the labour-market evidence has been interpreted. Several large enterprises, Uber prominently, are publicly questioning whether their AI investments are paying off. Anthropic’s internal productivity numbers are not externally audited — verification will arrive when the company’s IPO prospectus becomes public. And a single open-source developer poisoning his package against AI is not yet a movement.

But the cumulative shape of the evidence over the past six weeks is harder to dismiss than the pieces taken individually. Capability is compounding faster than the political and economic structures are adapting. The next decisive checkpoints will be the August release of the next quarterly BLS employment data, the mid-June release of an academic paper on actual AI usage rates, and whatever Anthropic discloses in its public IPO filing. Each of those will materially affect what can be said honestly about whether this is the early stage of structural workforce displacement, or whether the augmentation story holds.

What is clear is that this is no longer a question that can be deferred. The companies building the technology, the workers it is affecting, the state legislatures regulating it, and the politicians across the spectrum proposing radical responses are all now active in the same conversation, in real time. The months ahead will determine which way it tips.

Originally published at https://flux.robman.fyi.