What a model is and how many there are

In the previous steps I gave the engine a name —an LLM— and we saw that some stop to reason and others answer in one go. Now it's time to step aside and look at the landscape: there isn't one single engine, there are many, from various houses, and the word "model" means something more precise than I thought at first. Once I understood it, I stopped talking about "the AI" as if it were a single thing.

The test that explains the misunderstanding

Before counting how many there are, it helps to understand why it seems like you're talking to someone. Seventy-odd years ago, Alan Turing proposed a test now known as the Turing test: if you chat blind with a machine and with a person, and you can't tell which is which, the machine has passed the test. It doesn't measure whether the machine thinks; it measures whether it seems to.

And that seeming is exactly what throws you. When a chat answers you fluently, your head fills the gap and imagines someone on the other side. But think about who you imagine. If there really were a person, it could be a cultured adult with years of experience, or it could be a child who has barely read anything. They're not the same. A well-trained brain, one that has lived and read a lot, answers differently from one with little behind it.

It's the same with models, and that's why this links to what we saw: what a model knows is the position of its knobs, set during training. A large model, well trained on a lot of good text, is like that experienced adult. A small or badly cooked one is more like the child. On the other side there isn't a single figure: there are many, and each knows and performs differently.

The app isn't the model

Here's the distinction that tidied my ideas the most. What you open on your phone or the web —ChatGPT, for example— is the interface: the application, the box you talk to. Underneath, actually driving the answer, there's a model with its name and its version.

The app isn't the same as the engine that drives it. ChatGPT is the interface; the model it's got fitted is one of the GPT family, from the company OpenAI. And that same app can change engines: today one version answers you and in a few months a newer one does, with the screen barely changing. The box stays; the engine gets renewed. That's why you sometimes notice it "got better" or "answers differently" without having touched anything: they've swapped the model underneath.

When you separate the two things, you stop confusing the app's brand with what really determines the quality of the answer, which is the model.

How many there are and whose they are

There are many models. The public listings that catalogue them count hundreds, and new ones appear every few weeks. But the ones that really compete at the front line —the ones usually called frontier models— are a handful, spread across a few houses.

The main ones, as of today, are OpenAI with its GPT family, Anthropic with Claude, Google with Gemini and xAI with Grok. Alongside them, China's DeepSeek and Meta's Llama have gained a lot of weight, among others. You don't need to memorise the list: what matters is the underlying idea. There are several companies, each with its family of models, and within each family several versions that succeed one another.

I give these names as an example from June 2026, knowing they age fast. By the time you read this, some version will have gone stale and there will be new names. It doesn't matter: the map —several houses, several families— holds even when the pieces change.

Open and closed

There's one distinction between models that is worth carrying with you: that of open models and closed models.

A closed model you only use through its owner's service. You don't have the engine; they let you peek at it through a window, their app or their connection, and that's that. GPT, Claude or Gemini work like this. An open model, on the other hand, has downloadable weights: the company publishes the parameters —those knobs we saw, which in practice are the model— under a license that lets you download them, install them on your own computer or server and, often, modify them. Llama and DeepSeek are this type. Having the weights doesn't mean having everything: the data it was trained on is rarely published too. But the engine, that you do hold in your hand.

This difference has practical consequences —privacy, cost, control— that we'll touch on higher up the staircase. For now it's enough to know the two forms exist: the engine they only rent you and the engine you can take home.

"The AI" doesn't exist

With all this, the most widespread misunderstanding falls on its own, the one I was dragging around without noticing. When someone says "I asked the AI," they talk as if "the AI" were a single entity, a kind of oracle we all drink from. It isn't.

Whoever says that used a specific model: a version, from a house, with its cutoff date, its character and its limits. Another model, faced with the same question, would have answered differently. There's no AI; there are many models, and each conversation passes through one of them alone. Talking about "the AI" in the singular hides exactly what matters most: which one you were using.

Why choosing matters

From here comes something very practical. Since each model learned from different text and was tuned in a different way, the same task can give you different results depending on which one you ask. One writes better, another codes better, another is faster or costs you less.

You don't have to memorise names or versions; that's wasting time on something that expires. What is worth internalising is that you choose: that there's an engine behind it, that it isn't the only one, and that picking the right one for what you need changes the result. That idea —that the model is a decision, not a fate— is what opens the next step, where we'll see how the chat behaves differently depending on which one it's got fitted.

Definitions

- Model: the specific engine that generates the answer, with its name and version (GPT, Claude, Gemini...). It's what really determines how the chat answers. - Interface: the application you talk to (ChatGPT, for example). It's the box; underneath it carries a model that can change without the box changing. - Turing test: Alan Turing's test in which, if you can't tell the machine from a person chatting blind, the machine passes it. It measures whether it seems to think, not whether it thinks. - Frontier model: the few models competing at the front line of capability, as against the hundreds that exist in total. - Open model (downloadable weights): one whose parameters are published so that anyone can download and run them on their own. Llama and DeepSeek are examples. - Closed model: one you can only use through its owner's service, with no access to its parameters. GPT, Claude or Gemini work like this.

Further reading

- Artificial Analysis, LLM Leaderboard — Comparison of over 100 AI models — a live table of models by intelligence, speed and price; it lets you see at a glance how many there are and how the list changes. https://artificialanalysis.ai/leaderboards/models - Xavor, Claude vs ChatGPT vs Gemini vs Llama: Best AI Model in 2026 — a plain-language comparison of the big families and what each excels at. https://www.xavor.com/blog/claude-vs-chatgpt-vs-gemini-vs-llama/ - Pep Martorell, ¿Abiertos o cerrados? — plain-language explanation in Spanish of the difference between open-weight and closed models. https://pepmartorell.substack.com/p/abiertos-o-cerrados