The model and the application

Most of us open ChatGPT a few times a day. Or Claude, or Gemini. If you write code, you probably have Claude Code or GitHub Copilot running somewhere. And all the while you keep hearing about models. GPT-4 a while ago, GPT-6 Astra now, Claude Opus, Gemini Flash.

So here is a question I want you to try before reading on. What is the difference between ChatGPT and GPT-4? Or the newer GPT-6 Astra?

A lot of people, including very senior engineers, use these words as if they mean the same thing. They don’t. And once you see the difference, a lot of what comes later in this series gets easier.

ChatGPT is an application. GPT-4 and GPT-6 Astra are models.

A model is the trained LLM. You give it some text (and these days images too) and it gives you text back. That’s it. It doesn’t remember you between calls. It doesn’t have a chat history screen. It can’t search the web or read your files on its own. It’s a very capable function that takes input and returns output.

An application is the product someone builds around that model. ChatGPT is OpenAI’s chat application, and the GPT models are what it calls underneath. The app gives you the chat window, saves your conversations, lets you upload files, decides what to send to the model and what to do with the answer. On a paid plan you even get a model picker at the top. That picker is the clearest hint you’ll get. If you can choose the model inside the app, the app and the model can’t be the same thing.

What you use is the application; the model sees only what the application sends.

It’s the same with Claude. The Claude models (Fable, Opus, Sonnet, Haiku) are the LLMs. Claude.ai is a chat application built on them. Claude Code is a different application, built for coding, that runs in your terminal or IDE and reads your codebase, edits files and runs commands. Same family of models, two very different apps.

Google has the same split. There are the Gemini models, and there is the Gemini app you chat with.

Then there are apps that don’t belong to one model at all. GitHub Copilot lets you pick models from OpenAI, Anthropic, Google and others. Microsoft 365 Copilot was built on OpenAI’s models, and in 2025 Microsoft started adding Anthropic’s Claude models as an option in some parts of it.

Here’s a rough picture as of today.

If you’ve done system design, you already know this pattern. Think of a database engine and the application on top of it. Postgres stores and queries data. Your app has the screens, the business rules, the auth, the caching. Users talk to your app and never see Postgres. Nobody would say your app is Postgres. A model is the engine. ChatGPT and Claude Code are the apps on top.

Why does this matter if you just want to build something?

Because when you build, you do two separate things. You choose a model, and you build the application. Most of the time you rent the model. The application is your work. And the way your application reaches the model is the API.

Every provider says roughly the same thing in their docs. You get an API key from their developer console, and your code sends a request to their API with the name of the model you want. OpenAI, Anthropic and Google all work this way. That’s what people mean by API access. You get the model with nothing around it, and you pay for what you use.

This is also why one model can sit behind many apps, and one app can use many models. The Claude models are behind Claude.ai, Claude Code, and also behind GitHub Copilot when you pick them there. GitHub Copilot, in turn, can call models from several companies. The model is a dependency. Apps choose it, and can swap it.

When you start calling the API yourself, two more choices show up. I’ll keep them short because we’ll come back to them.

The first is open-weight versus closed. With a closed model like GPT, Claude or Gemini, you never get the model itself. You call it over the provider’s API. With an open-weight model, the trained weights are published and you can run the model on your own hardware or your own cloud. Google’s Gemma is one example. Google describes it as a family of open models built from the same research as Gemini, and you can run it in your own applications and on your own machines.

The second is size, or tier. Most providers ship a family of models in a few sizes. Anthropic has Fable, Opus, Sonnet and Haiku. Google has Pro, Flash and Flash-Lite. Bigger ones are usually more capable and slower and cost more. Smaller ones are faster and cheaper. You pick the one that fits the job, and a lot of real systems use more than one.

Now, where does this tidy split break down?

The application does a lot more than people think. It writes a system prompt you never see. It decides how much of your old conversation to send each time. It might search the web, read files, call tools, or trim things to fit. So the same model can feel very different in two apps. Claude in Claude Code doesn’t behave like Claude in Claude.ai, and that is mostly the app. When someone says “the model got worse this week”, it’s often the app that changed. And the line goes the other way too. Providers train their models to work well inside their own apps, so the model and the app are not as independent as my Postgres picture suggests. Treat the split as a way to ask better questions. Which part changed? Which part am I responsible for?

For me, this is the first thing to get straight. Everything you’ve used so far is an application wrapped around a model. When you build, you’re building that wrapper.

Next we’ll give the parts of that wrapper proper names. Model, harness, agent, product, and what LangChain, Microsoft and Anthropic each mean when they use those words.