The Era of Throwing Frontier Models at Everything Is Over

A few days ago, OpenAI released GPT-6 Luna. At first glance, Luna might look like another cheaper model in an increasingly crowded model landscape, but I think it represents something more important: the age of casually throwing the most expensive frontier model at every problem is coming to an end.

Not because frontier intelligence is becoming less useful, but because we are finally learning how expensive that habit is.

Money Talks#

For a long time, my default approach was simple: use the strongest model available. Code review? Frontier model. Write some tests? Frontier model. Refactor a straightforward module? Frontier model. Summarise a diff? Frontier model. Clean some data? Frontier model.

It feels great when you are building this way. You have enormous capability available on demand, so why not use it? Then you look at the bill…

I got burnt doing exactly this. The problem becomes even more obvious once you start building agentic systems. A human might make one model call and move on, while an agent may make dozens of calls, repeatedly read context, inspect files, reason, call tools, evaluate results and try again. Suddenly a task that looked like a few cents of intelligence becomes millions of tokens. At that point, model selection stops being an interesting benchmark discussion. It becomes an essential part of system design.

GPT-6 Luna: Intelligence Designed for Volume#

OpenAI released GPT-6 Luna on 22 September 2026 as the efficiency-oriented model in the GPT-6 family.

Its Standard API pricing for shorter-context requests is currently:

$0.10 per million input tokens
$0.01 per million cached input tokens
$0.50 per million output tokens

It supports a 1.05-million-token context window, multimodal input, tool calling, structured outputs and adjustable reasoning effort.

I call it, the perfect Engineering workhorse.

Cheap models have existed for years. What is different this time is that the capability floor has moved.

A model at this price can now perform a surprisingly large percentage of normal engineering work: generating boilerplate, writing tests, analysing logs, summarising changes, transforming data, executing tools, doing straightforward refactors and handling routine agent steps. That changes the economics of AI systems.

For genuinely difficult work, such as architectural reasoning, ambiguous refactors, difficult debugging, high-stakes reviews or problems where additional reasoning materially changes the answer, I can still escalate to something like GPT-6 Sol. But Sol no longer needs to be the default executor. Luna can do the volume work.

DeepSeek V4.1 Flash Shows the Same Pattern#

DeepSeek is moving in almost exactly the same direction.

Its recently released DeepSeek V4.1 Flash, available through the API as deepseek-flash, supports a 1-million-token context window, native multimodal input, tool calling and both thinking and non-thinking modes.

Current off-peak API pricing is roughly:

$0.15 per million uncached input tokens
$0.60 per million output tokens

Peak pricing is approximately double. The model weights are also available under the MIT licence.

Architecturally, DeepSeek has gone aggressively after inference efficiency. V4.1 Flash uses a 552B-parameter Mixture-of-Experts architecture but activates far fewer parameters during processing.

That detail may sound obscure, but it explains where the competition is heading.

Building the smartest model matters less now than delivering enough intelligence per dollar, per watt and per second to make large-scale autonomous workloads economically viable.

That is a much more interesting competition.

We Have Seen This Movie Before#

This transition reminds me of what happened with earlier technologies.

Consider television. The earliest television sets were expensive, technically impressive objects accessible to relatively few households. Over time, manufacturing improved, components became cheaper, supply chains scaled and competition increased.

Eventually the interesting question stopped being whether we could manufacture a television and became how cheaply we could manufacture a good television.

The same thing happened with computers. Mainframe compute was once scarce and extremely expensive. Then came minicomputers, PCs, laptops, smartphones and eventually tiny embedded computers sitting inside everything from cars to washing machines.

Computing did not become less important as it became cheaper. It became ubiquitous instead.

AI appears to be entering the same phase.

The Frontier Still Matters#

None of this means frontier models are becoming irrelevant. Frontier systems remain extremely valuable when the task actually requires frontier capability: difficult scientific reasoning, complex engineering, long-horizon autonomous work, novel research or situations where the cost of an incorrect answer massively exceeds the cost of inference.

The mistake is using that capability indiscriminately.

You probably do not need your smartest available model to rename variables, classify support tickets, summarise a build log or write another CRUD endpoint.

The same principle already exists everywhere else in computing. We do not run every workload on the largest available VM, store every file on the fastest storage tier, or send every database query to the most expensive compute cluster.

We match resources to workloads.

AI inference is becoming another resource-allocation problem.

The Advisor Pattern#

Instead of:

Human → Frontier Model → Everything

I increasingly expect serious AI systems to look more like:

Task → Cheap Executor → Escalate on Uncertainty → Strong Model → Continue Execution

The inexpensive model handles the majority of the work. The stronger model appears only where additional intelligence has expected economic value. In fact Anthropic, LiteLLM and others now offer the Advisor tool as a primitive for building agents.

For example, an engineering agent might let Luna inspect files, run tests, make straightforward edits and summarise results. If it encounters an architectural ambiguity, repeated test failure or an unfamiliar subsystem, it can ask Sol a very specific question.

Sol does not need the entire workflow. It needs the uncertainty.

The answer comes back, the cheaper executor continues working, and the expensive intelligence disappears again until needed. That is a very different operating model from simply running an entire 30-turn coding session through your most expensive model.

As you can imagine, at large scale, the difference becomes enormous.

Model Routing#

The more I build with agents, the more I think model routing will become as normal as compute scheduling.

A mature system should decide dynamically:

How difficult is this task?
How much reasoning does it need?
Can cached context be reused?
Does this step require vision?
Does it require tool use?
How expensive would failure be?
Should the system escalate?
Can the work happen asynchronously during cheaper inference windows?

The objective is not to minimise model cost at all costs. The objective is to minimise the cost of successfully completing the task.

That distinction matters. A cheap model that repeatedly fails can be more expensive than an expensive model that succeeds immediately.

The interesting metric therefore becomes something closer to cost per successful unit of work, not cost per token and certainly not benchmark score in isolation.

From Model Obsession to Systems Engineering#

For the last few years, much of AI discussion has centred on model capability. Which model tops which benchmark? Which one codes better? Which one reasons harder?

Those questions still matter, but production AI is increasingly becoming a systems problem.

The winning systems will combine different levels of intelligence with caching, tools, context management, permissions, observability, retries, escalation rules and budgets. In other words, the model becomes one component inside a larger execution system.

This is especially important for agents. If agents are ever going to perform economically useful work continuously rather than remain impressive demos, inference economics have to work.

You cannot have an autonomous worker casually burning premium frontier tokens every time it needs to inspect a log file.

The Practical Era#

GPT-6 Luna and DeepSeek V4.1 Flash therefore matter to me for a reason that goes beyond their individual benchmarks. They are signals.

They suggest that highly capable intelligence is moving down the cost curve quickly enough that we can begin designing AI systems around abundance rather than scarcity, while still reserving frontier intelligence for the moments where it matters.

Technologies become infrastructure when a sufficiently capable version becomes cheap enough to use everywhere, not when the most impressive version exists.

The era of blasting the biggest model at every problem was fun. I participated enthusiastically. My API bills can confirm it.

The question that matters now is which is the cheapest intelligence that can reliably complete the work in front of you.

References#

OpenAI. Introducing GPT-6 Sol and Luna. September 2026.
https://openai.com/index/introducing-gpt-6-sol-and-luna/
OpenAI. GPT-6 Luna model documentation.
https://developers.openai.com/api/docs/models/gpt-6-luna
OpenAI. API Pricing.
https://openai.com/api/pricing/
DeepSeek. Models & Pricing. API documentation.
https://api-docs.deepseek.com/quick_start/pricing/
DeepSeek AI. DeepSeek-V4.1-Flash model repository. Hugging Face.
https://huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash