Simply put: frontier AI. Why the most intelligent AI is not always the best solution.

I have explained this so many times in recent months, at the kitchen table, on the phone, in customer meetings, always in my simple way, that I decided to write it down once. Then I can send the link in future. The occasion was an article at BASIC thinking with the fine title "Frontier AI: what the hell is that anyway?". Good question. Here is my answer, simplified, and as always the way I see it.

What frontier AI means

Imagine a school class of thirty children. Some are very good at mathematics. Others at languages, history, chemistry. And then there is one who is at the very front in almost every subject. That child is, simply put, the frontier model.

Frontier means nothing more than: at the edge of what is technically possible right now. The large models of the GPT, Claude or Gemini families belong there. But not every model from those families is one; the small siblings are not. And what is the edge today is midfield in a year. Frontier is not a state, it is a position in a race.

Regulators need a measurable line and draw it at training effort: the EU AI Act presumes "systemic risk" from 10 to the power of 25 operations in training. That is a one with 25 zeros. You do not have to remember the number. You only have to know that it is a convention, not a constant of nature, and that it says nothing about whether the model is the right one for your task.

How a model learns at all

A classic programme is written by a human: if A happens, do B. Every rule is put there by hand. A language model comes about differently. You show it huge amounts of text, code, images, and it learns which connections are probable and which are not. In the process, billions of numeric values are adjusted, the so-called parameters. No book and no web page is stored in those parameters. What is stored there are learned patterns.

Why it costs hundreds of millions

Imagine you want to teach a person a million books. They have to read, connect, check, read again. A model does not do that with a brain but with arithmetic, and it needs an enormous amount of it. Thousands of processors are wired together and compute for months. That costs power, hardware, buildings, and in the end hundreds of millions of dollars for a single training run.

And here sits the most common misunderstanding I have to clear up at the table: more compute does not automatically mean more intelligence. The quality of the data counts, the architecture, the procedure, the fine-tuning afterwards. A smaller model can be better at a specific task than a much larger one. That is not an exception to the rule. That is the rule. I described it in October in an article of its own, it had just come up in a Harvard study: mass helps, but not everywhere, and not linearly.

Can an AI suddenly do things nobody programmed?

Yes, it can show capabilities for which nobody wrote instructions. The word for that is emergence. You train with text, mathematics and code, and at some point the model solves programming tasks that never appeared in the data in that form. It looks like a leap.

I am careful there. Often these capabilities develop gradually, and only a particular test with a particular threshold makes them look like a sudden leap. The capability is real. The explanation "it just emerged" is usually too short. Observed capability and scientific explanation are two different things, and I say that to everyone who comes to me with "the AI can suddenly".

When a chatbot becomes an agent

This is where most articles cheat. They give the impression that a model strong enough will at some point do tasks by itself. It is not like that.

A developer asks a model: "Why does my application not run?" The model reads the description and proposes a fix. That is a chatbot. Now we give the same model access to the source code, to the tests and to a fenced-off development environment. Then the system can analyse the error, examine the code, make a proposal, build it into the test environment, run the tests, check the result and improve it.

Now we have an agent. Not because the model has gained consciousness. But because we connected it to tools, permissions, processes and controls. That is where a large part of the actual engineering work sits, and that is where it is decided whether the thing is reliable. A strong model alone is not yet a reliable system. It is the child who can do every subject but has never worked in a company.

Why small models matter more

Now to the point that gets too little attention in the public debate. Why should a company use the strongest and most expensive model for every task?

An invented example: a company processes a thousand invoices a day. Recognise invoice data, read out number and amount, compare with the order, report deviations. Do you need a model for that which solves scientific problems, develops software and can discuss philosophy? No. A small, specialised model is enough. It is probably more reliable, because it can do less and therefore produces less nonsense. It is cheaper and faster. And it can run on your own infrastructure, so the data stays in the house, provided access rights, logging and the rest of the infrastructure are clean.

The future does not necessarily belong to the biggest model

A look back helps. Many calculations used to need mainframes that filled whole rooms. Today you carry a device in your trouser pocket that is more powerful in many respects. Not only because processors got faster. But because algorithms, memory, architectures and hardware were improved over decades.

In AI we see the same, only faster. New architectures, quantisation, distillation, more efficient training methods. Quantisation means: the numbers in the model are stored less precisely, the model gets smaller, and for most tasks quality hardly suffers. Distillation means: you transfer the capabilities of a large model to a small one, the way a good teacher teaches a pupil the essentials without the pupil having to read every book. Both have limits. A small model does not solve the same complex tasks as the top model. But that is not the point. The point is not to solve every problem with maximum compute, but to use compute wisely.

And how safe is it?

A strong model delivers impressive results. It can also be wrong. It can make false connections, write faulty code, or take a manipulated piece of information for trustworthy. That becomes critical as soon as an agent is allowed to access databases, emails or company systems on its own.

An invented example: an agent checks incoming invoices. In one invoice, invisible to the human, sits an instruction to the agent to change the bank details. That is called prompt injection. The problem is not primarily the model's intelligence. The problem arises when a system does not cleanly separate information, instruction and permission. That is why AI systems need clear boundaries, controlled tool access, independent checks, and for critical decisions a human who approves. That holds for large and small models alike. Two weeks ago I wrote why the most dangerous AI is the one that wants to help, and a week ago why it was not the model that was hacked but the environment around it. Both belong here.

What this means for companies

We often ask the wrong question in the debate. We ask: which model is the most intelligent? We should ask: which system solves our problem most reliably, most economically and most safely?

Perhaps a difficult analysis really does need a frontier model. Perhaps a small model in-house is enough for daily document processing. And very often the best solution is a combination: several models, classic algorithms, and clearly defined business processes that say who may do what. That is exactly where I see the task of modern software development. Not to build in as much AI as possible. But to understand where it makes sense, which tasks it should take on, and how we reliably check its results.

What remains

Frontier AI is not a mysterious new form of intelligence. It is a word for the models currently standing at the edge of the feasible. They are impressive and drive development. But they are not autonomous by themselves, not infallible, and not the best choice for every application. The next big advances, the way I see it, will come not only from training ever larger models with ever more compute. They will come from using existing capabilities more efficiently, specialising models, and building the systems around them better.

Sources