What an AI model is and what an agent is

Model, agent, memory, tools, skills. We use these words every day and almost nobody is sure what each one names. And there's one confusion I want to undo more than any other: the feeling that "the model learns from me". It doesn't. What actually happens is simpler, more interesting, and worth understanding if you want to use these tools well.

A model is a file

Stripped of all the marketing, a language model is a file of numbers. Billions of numbers — the "parameters" — encoding patterns extracted from an enormous amount of text. That file does exactly one thing: given a sequence of words, it computes which word is most likely to come next. Repeat that many times per second and you get a paragraph.

"Predicting the next word" sounds like a parlor trick, but inside that prediction there's a web of relations between every word in the context — in the previous article I showed what that web looks like from the inside, with the figures from the 2017 paper that invented the architecture. To correctly predict what follows in "the diagnosis for the patient with fever and neck stiffness is...", the model had to encode something that works like medical knowledge. Prediction is the mechanism; what emerges is harder to name.

The key fact for everything that follows: that file is frozen. When you talk to a model, its numbers don't change. Not one. The file is identical before and after your conversation — for you and for the hundreds of millions of other people who talked to it today.

How it's trained

If the file is frozen, where did the numbers come from? From a three-stage process, each stage more industrial than the last:

1. Pre-training. The model reads a giant slice of the internet and entire libraries, adjusting its numbers to predict each next word. Months of compute, tens or hundreds of millions of dollars. This is where knowledge and language come from.
2. Fine-tuning. The raw model knows how to continue text, not how to converse. It's shown tens of thousands of curated examples of good responses: questions with answers, instructions followed well. This is where the assistant behavior comes from.
3. Reinforcement from human preference (RLHF). People compare pairs of responses and mark which they prefer; the model is nudged toward the preferred ones (the paper that introduced the technique). This is where the tone comes from: helpful, careful, willing to say "I don't know".

The economic asymmetry explains most of the business: training costs millions and happens once; answering costs cents and happens billions of times. That's why models have a "knowledge cutoff": whatever happened after training isn't in the numbers. And that's why they don't learn from your conversation — updating the file for every user would be technically and economically absurd, and a serious privacy problem: what it learned from you could leak out to someone else.

"But it remembers me": what memory actually is

So how can your assistant know your name, your job, and what you told it last week? Here's the concept most worth taking away from this article: the context window.

Besides its frozen numbers, the model has a text input: everything it can "see" while answering. Your question travels there, but it doesn't travel alone. The product you use — the chat, the assistant — prepends things to it: behavior instructions, the conversation so far, and a dossier about you: notes the system saved about you in a perfectly ordinary database.

When the assistant "remembers" you're an architect, the model hasn't learned anything. Before your question, the system pasted in a text that says something like "the user is an architect, lives in Guadalajara, prefers short answers". The model reads it — like it reads everything in its window — and answers accordingly. "Memory" is a document someone reads to the model before it answers you, not a change in who answers.

The proof is one click away: delete that dossier in any assistant's settings and the "memory" vanishes entirely. If the model had learned, there would be nothing to delete. Personalization is context engineering: deciding what information to inject into the model on each call. It's literally the same thing I do when I paste in a building code so it can answer questions about it.

Model vs agent

Now we can draw the line that causes the most confusion. A model takes text in and gives text back. Once. It does nothing else: it doesn't browse, doesn't execute, doesn't wait. An agent is a model placed inside a loop, with three things the bare model doesn't have:

1. A goal that persists across steps: "research these three suppliers and prepare a summary".
2. Tools: actions it can invoke — search the web, read a file, send an email, run code. The model doesn't execute them; it *requests* them, and the system around it executes them and feeds the result back as more text in its window.
3. The loop: after each result, the model decides the next step. Act, observe, decide again, until the goal is done.

Skills — another word of the moment — are packages of instructions and procedures injected into the agent when the task calls for them: how to write in the company's style, how to process an invoice, what steps to follow to publish. Notice the pattern, because it's always the same one: none of this modifies the model. Memory, tools, skills — it's all context flowing in and out of the window. The model is the engine; everything else is what we build around it.

Is my data being used for training?

It's the question I get asked most, and the correct answer is uncomfortable precisely because so few people know it: it depends on the door you enter through, not on the company. The same companies run two different regimes.

The consumer door — the chat you open in a browser — can feed training. ChatGPT does it by default on personal accounts, free and paid, unless you turn it off in settings. Claude asks you, and if you accept it can retain your conversations for up to five years for training. Gemini uses your activity unless you switch it off. It's not "only free users": it's anyone who never touched the settings.

The API door — the one used by products built on top of these models — runs on a different contract: that traffic is not used for training by default, and retention is short and audited. It's the difference between walking into a store and signing a commercial contract with the same supplier.

An example I know firsthand, because it's mine: in Kouzee, when someone uploads a photo of their living room to redesign it, that image travels to the models through the API, not through a chat. It doesn't enter the training cycle and it doesn't live on the provider's servers: it stays in Kouzee's database, under our rules. Paradoxically, uploading your home to a small product built on the API can be more private than uploading it to the giant's free chat — if you never touched the settings, the chat has permission to train on it.

And the same principle, one level up, is the foundation of my other company: at Zapians we build digital employees for businesses, and there the architecture described in this article becomes data policy. The model is consumed through the API — that traffic trains no one — but every tool, every memory and every interaction runs through the harness we build: the layer that turns a model into an agent is the same layer that decides which data it sees, which actions it may request, and where everything gets logged — in each company's private database. And for data that must never leave home, the next step already exists: open models deployed on private servers, where information never crosses the company's door. Understanding the difference between model and agent isn't theory: it's exactly where who-sees-your-data gets decided.

Two pieces of fine print worth knowing. Opting out is always forward-looking: what a model already trained on cannot be untrained. And turning training off doesn't delete your conversations — retention (how many days the provider keeps your data) is a separate knob.

Why any of this matters

This isn't trivia; it changes concrete decisions. If you know the model doesn't learn from you, you stop waiting for it to improve on its own and start writing better context — which is what actually improves the answers. If you know memory is a dossier, you know where to look when the assistant "gets you wrong" and what to delete. If you can tell model from agent, you can evaluate products without drowning in words. And if you know that consumer chat and API are different regimes, you can decide with real information what you upload, where, and which setting to check first.

The model is a frozen file that completes text. Everything else — memory, tools, agents, skills — is architecture around that piece. And that architecture, unlike the file, is something we get to design.