Understanding AI and mastering its jargon

Seen from very high up, AI looks like an invention from 2022. Yet it is seventy years old, with two winters behind it and a large family. Let’s start by putting each word in its place.

Short form: AI.

The term was born in 1955, in a funding proposal. John McCarthy, Marvin Minsky, Nathaniel Rochester and Claude Shannon proposed holding a workshop on “artificial intelligence” at Dartmouth College the following summer. Their bet: every aspect of intelligence can, in principle, be described precisely enough for a machine to simulate it. The workshop took place in 1956. The name stuck; the definition, on the other hand, was never really settled.

• Recognising a face
• Translating a sentence
• Playing chess
• Summarising a contract

It is also the most modest. And it has an amusing property: it moves back as we move forward. This is sometimes called “the AI effect”: as soon as a machine can do something, we stop finding it intelligent.

Symbolic AI, expert systems; machine learning, ML.

For decades, two schools fought over the field. Their disagreement boils down to one question: to teach a machine to recognise a cat, should you describe one to it, or show it one?

Immersion won, and by a long way: almost everything we call AI today learns from examples.

Seventy years, two winters

The history of AI is not a straight line. It is a succession of seasons: springs of enthusiasm, when people promise the moon, followed by winters when funding freezes, because the moon never came.

A few milestones, to get our bearings.

1. 1950
   The imitation game

   Alan Turing asks the question: if a machine converses without anyone being able to tell it apart from a human, do we still have the right to say it doesn’t think?

2. 1958
   The perceptron makes headlines

   The ancestor of today’s neural networks, built by Frank Rosenblatt. The New York Times reports that the US Navy expects it to lead, eventually, to a machine able to walk, talk, see, write, and be conscious of its own existence. Prophecies are nothing new.

3. 1966
   ELIZA, and the effect named after it

   At MIT, Joseph Weizenbaum writes a program that imitates a psychotherapist by rephrasing what the other person says. The trick is rudimentary, but some users credit it with real understanding; Weizenbaum recounts that his own secretary once asked him to leave the room so she could talk to the program alone. Ever since, people have spoken of the ELIZA effect: our tendency to attribute thought to anything that talks well. Keep it in mind, it will come in handy again.

4. 1974
   The first winter

   The promises aren’t kept, funding freezes.

5. 1980
   The spring of expert systems

   Thousands of hand-written rules get the machine going again.

6. 1987
   The second winter

   It turns out that maintaining thousands of rules costs a fortune and breaks at the first unforeseen case. Then computing power and data from the Web change the game.

7. 2012
   AlexNet

   A neural network crushes the competition at the ImageNet image recognition contest: the kick-off for deep learning.

8. 2016
   AlphaGo

   The machine beats champion Lee Sedol at the game of Go, long thought out of reach.

9. 2017
   The Transformer

   A Google team publishes Attention Is All You Need, which describes a new network architecture. Remember the name: it is the T in ChatGPT.

10. 2022
    ChatGPT

    It comes out on 30 November and reportedly reached 100 million users in about two months, according to an estimate by the bank UBS: unheard of for a consumer app.

11. 2024
    A Nobel Prize

    The Nobel Prize in Physics goes to John Hopfield and Geoffrey Hinton for their foundational work on neural networks. The rest, you are living through.

AI, machine learning, deep learning, generative AI, LLM.

Here is the first confusion to clear up. People use AI, machine learning, deep learning, generative AI and LLM as synonyms.

They are not synonyms, they are Russian dolls: each term is a special case of the one before.

Let’s open the dolls one by one, from the outside in.

The engine and the car; and the API, the engine on its own.

Second confusion, probably the most widespread: the model and the product.

GPT is a family of models; ChatGPT is a product.

Claude is a model, and also the name of the app that makes it available. Same for Gemini. The vendors themselves keep the confusion going, but the distinction is simple.

Same colour, same family: ChatGPT runs on a GPT engine, Le Chat on a Mistral engine, Meta AI on Llama. In grey: no simple match.

This distinction has very concrete consequences. Two products can use the same engine and give very different results, because the bodywork matters: the hidden instructions, the connected tools, the memory.

We’ll meet this bodywork again in Part 4, under another name.

AGI, for artificial general intelligence; sometimes “superintelligence” for the step after that.

One word still floats above the map, like a cloud: general AI.

There is no shared definition of it, which lets everyone announce that we’re getting close. So I file it among the horizons, like the word “AI” in 1956: useful for finding your bearings, not for planning a budget.

Down to 1,000 km. From here, only one country is in view: the LLM. You don’t need any maths to visit it, just a few well-chosen pictures. By the end of this part, you’ll know what a parameter, a token, a temperature and a hallucination are, and why they are four facets of one and the same idea.

Also called pre-training.

It all starts with reading. A very long read. The future model is fed a huge share of everything humanity has written that is accessible: web pages, books, scientific papers, code, forums.

And the exercise? Just one, repeated trillions of times: guess what comes next.

We hide the next word of a text, the model makes a guess, we show it the right answer, and it corrects itself a little. It’s a giant fill-in-the-blanks:

• “The cat drinks itsmilk
• “The capital of Italy isRome
• def addition(a, b): returna + b

What’s dizzying is what this seemingly silly exercise ends up producing. To correctly guess what comes next in millions of different texts, memorising isn’t enough: you have to pick up grammar, facts, typical lines of reasoning, styles, languages, the structure of code. Nobody programmed this knowledge. It settled, like sediment, through sheer guessing.

This reading is expensive. That’s why only a handful of companies train the most advanced models.

Also called the weights.

Back to our mixing desk. Each time the model gets the next part of a text wrong, training turns billions of knobs ever so slightly, so that it gets it a little less wrong the next time.

A crucial point, often misunderstood:

That’s why an LLM is not a search engine.

The difference looks subtle; it explains nearly all of its flaws, as we’re about to see.

French sometimes says “jeton”, but “token” is the word that stuck, in every language.

The model reads neither letters nor words.

These pieces are fixed once and for all, before training. Common words fit in one token; rare words are split into several.

Why care? Because the token is three things at once:

Also called generation, or inference (more on that below).

We now have all the pieces. When you ask an LLM a question, here is what really happens:

1. The model reads your text.

2. For each token in its vocabulary, it calculates the probability that it comes next.

3. It picks one and adds it to the text.

4. It starts again. Token after token, until it decides the answer is finished.

That’s why answers appear word by word, as if someone were typing: it isn’t a stylistic effect, it’s how they are made.

The model didn’t write its answer in advance: it produces it as it goes.

And its cousins top-p and top-k: the settings of the random draw.

At each token, the model doesn’t impose a choice: it offers a ranking, with probabilities. Then something has to be drawn from that ranking.

Try it:

That’s also why the same question, asked twice, doesn’t give the same answer twice. It isn’t a flaw, it’s the draw. In consumer apps, this setting is fixed for you; in APIs, it’s one parameter among others.

Also called confabulation; in plain terms, something made up and presented as fact.

If you’ve been following, you already understand hallucination.

Most of the time, the two coincide, because the truth is what you find most often in texts. But when the model doesn’t “know”, it doesn’t stay silent: it still produces a plausible continuation. A credible author’s name, a believable date, a neatly formatted reference, and entirely made up.

Two stories, to gauge the consequences:

Three ways to reduce it:

• Give the model its sources, rather than relying on its memory (Part 3)
• Ask it to cite them
• Check what matters

Instruction tuning, RLHF (reinforcement learning from human feedback), alignment.

A model fresh out of pre-training is an odd creature. It can continue any text, but it doesn’t know how to hold a conversation.

This upbringing comes in a second stage, in two moves:

1. It is shown thousands of examples of good answers to requests.

2. People compare its answers and state their preferences: this one is more helpful, that one more honest, this other one dangerous. That’s RLHF, popularised by OpenAI in 2022 with InstructGPT, the direct forerunner of ChatGPT.

More broadly, this is called alignment: making the model helpful, honest and harmless, according to rules chosen by its vendor.

This is where an assistant’s “personality” is born: its politeness, its caution, its refusals, the way it structures an answer.

Two models trained on similar texts can have very different characters, because they weren’t brought up the same way.

Also called the training cutoff, or the cutoff date.

A direct consequence of the above:

Whatever happened afterwards, it doesn’t know, unless someone brings it in.

The moment the model is used, as opposed to the moment it is trained.

There are two moments in a model’s life:

This vocabulary matters because a growing share of the bill, and of the energy consumption, comes down to inference: hundreds of millions of people ask questions every day, and every answer has a computing cost. It’s invisible in a free app; it’s very visible on an API invoice.

Reasoning models, models that “think”, thinking models.

In late 2024, a new family appeared.

1. 2024
   o1

   In September, OpenAI unveiled its first reasoning model.

2. 2025
   DeepSeek R1

   In January, the Chinese company DeepSeek released a model with comparable performance, freely available.

What sets them apart: before answering, they produce a long sequence of thinking tokens, a scratchpad. Then they write the final answer.

• Break the problem down
• Try an approach
• Check it
• Self-correct

Nothing magical: it’s still token prediction. But these models have been trained to use that scratchpad productively.

As for whether these models really “think”, the word is convenient, and the debate over what it covers remains open.

Text, image, sound, video: several “modalities”.

The first LLMs only read and wrote text. Most of today’s models are multimodal: they accept many other things, and some also produce images or speech.

• Images
• PDFs
• Screenshots
• Audio
• Sometimes, video

Closed models, models with open weights, small models, local models.

One last landmark before we leave this country: not all models are distributed the same way.

As for exact names and version numbers, I’m deliberately leaving them out: every vendor releases a new one every few months, and the ranking of the best models changes almost as often. Remember the families and the vendors; the news will take care of the versions.

That last trait deserves a pause, because it’s rarely stated clearly. The model retains nothing from your exchanges: it doesn’t train by talking to you. If your assistant seems to remember you, it’s the app slipping it notes, as we’ll soon see.

At 10 km, you start to make out the streets. This is where everyday use plays out: what you tell the model, what you show it, what you have it read. A good share of the gap between a mediocre result and a stunning one is decided in those streets.

Sometimes called a query, a request or an instruction. The word comes from the theatre, where the prompter whispers the forgotten line.

It’s the best-known word in the jargon, and yet the most underrated.

If the model is a colleague with no memory, the prompt is the only brief it will ever get.

It knows nothing of your company, your project, your tastes, or anything on your mind that you haven’t written down.

There’s nothing magic about the second prompt (the company is made up for the example). It contains what you’d give a freelance writer discovering the company: the context, the audience, the tone, the constraints, the format, an example. The ingredients of a good prompt are those of a good brief, and that’s no coincidence.

The history, the back-and-forth, multi-turn.

But then, if the model remembers nothing, how does it know what I told it three messages ago? It doesn’t.

With every new message, the application sends it the whole conversation from the start: your messages, its replies, then your new request.

The model rereads everything, every time, and predicts what comes next.

Two practical consequences:

The context, the context window.

This is probably the most important idea in this article, because much of the jargon that follows stems from it. The best picture is a desk:

And the desk has a limited size. The word “window” puts it very well, in fact: what’s in the frame is seen, the rest isn’t.

The size of this desk has exploded:

But a big desk isn’t a tidy desk.

System instructions, system prompt; and its consumer versions: custom instructions, projects, custom assistants.

On this desk, there’s a document you usually don’t see.

Role, tone, rules, limits. For example:

Consumer assistants all have one, often several pages long. And you can write your own: what applications offer under these names are system prompts you write once, which then apply to every relevant conversation.

• Custom instructions
• Projects
• Custom assistants

Long-term memory, personalisation.

How, then, do some assistants remember your first name, your job or your preferences from one conversation to the next? Through an honest sleight of hand: the application jots down information as you chat (or lets you jot it down), then puts it on the desk at the start of each new conversation.

The model doesn’t remember; it’s made to reread its notes.

So there are two kinds of memory to tell apart:

Prompt engineering; zero-shot, few-shot, chain of thought, structured outputs.

From 2022 onwards, a small craft grew up around the prompt, with its own jargon. It boils down to four moves, which are, once again, those of a good brief.

Yesterday’s magic formulas have lost most of their appeal. Clarity hasn’t lost any of its own.

In plain words: engineering the context.

In the summer of 2025, a new term caught on, popularised notably by Tobi Lütke, Shopify’s CEO, then by Andrej Karpathy: context engineering. The real skill isn’t finding the magic formula:

The change of word says something about the times:

One practical question remains: what if the information the model needs isn’t in its memory, but in your documents? It has to be fetched. And for that, you first have to teach the machine to search by meaning.

Vectors, vector representations; hence semantic search and vector databases.

On this map, texts that mean the same thing are neighbours, even if they have no word in common. “Cat” lives near “kitten” and “feline”, far from “invoice”. The real map has hundreds of dimensions instead of two, which makes it impossible to draw, but the principle is exactly the same.

Searching by meaning then becomes a matter of geography: you compute the coordinates of the question, then look for the closest documents. That’s semantic search. The specialised databases that store these coordinates to find them quickly are called vector databases.

Retrieval-Augmented Generation: generating an answer from retrieved documents.

We now have everything we need to understand one of the most-spoken acronyms in business. RAG, described in 2020 by researchers at Facebook AI Research, brings the two worlds together.

Picture an internal HR assistant.

And nothing to retrain when a document changes: you just update the database. Yet RAG has its limits, often underestimated:

When a RAG project disappoints, the culprit is rarely the model: most often it’s the documents, or the way they’re searched.

Tuning, adapting a model: specialised retraining.

One last way to adapt a model: change the model itself.

• Always answer in the structure of your reports
• Sort tickets into your categories
• Speak the jargon of your trade

Fine-tuning changes the manner, not the knowledge.

The recommended order is almost always the same:

1. First, a good prompt.

2. Then RAG, if the model lacks information.

3. Fine-tuning as a last resort, when the first two have shown their limits.

We’re skimming the rooftops. This is the newest district on the map, the one that moves fastest and coins the most new words: tools, agents, agentic, MCP, skills, subagents. Good news: if you’ve followed along so far, you already hold all the keys. This whole district is built on two ideas we’ve already seen: text prediction and the desk.

Tools, function calling, tool use.

Starting point: a model can only produce text. It can’t click, calculate reliably, or read the Web.

The trick, which became widespread in 2023, is disarmingly simple:

1. You put a list of available tools on the desk, with a manual for each: “weather(city, day) gives the weather forecast”.

2. When the model judges that a tool would help, instead of writing its answer, it writes a request to use it, in an agreed format.

3. The program around it actually runs the tool, then puts the result on the desk.

4. The model then takes over again, with this extra information.

// 1. On the desk: the request, and the manual for the available tools
User:  Do I need an umbrella in Lyon tomorrow?
Tools: weather(city, day)

// 2. The model doesn’t answer yet: it asks for a tool
→ weather({ "city": "Lyon", "day": "tomorrow" })

// 3. The program runs the tool and puts the result on the desk
← { "sky": "showers", "rain": "80%", "max": "14 °C" }

// 4. The model finally writes its answer
Yes: showers are forecast in Lyon tomorrow (80% chance). Take an umbrella.

With this mechanism, you can plug in anything:

• Web search (goodbye, cutoff date)
• A code interpreter (goodbye, calculation errors)
• Your calendar
• Your CRM
• Your database
• Sending an email

The model still only writes text; it’s the program around it that acts.

This separation is essential: it’s precisely where permissions go, as we’ll see.

AI agent; and the agentic loop.

Now let’s have the model use tools not once, but in a loop, as many times as it deems necessary, to reach a goal. It looks at where it stands, picks an action, carries it out via a tool, observes the result, and starts again, until it reckons the mission is accomplished. That’s an agent.

The difference from a classic assistant comes down to one word:

I talked about this in my previous article: working with agents is like managing a team of interns who are very fast, very well-read, tireless, and perfectly capable of messing up with total confidence.

The more autonomy they have, the more the framework matters.

Agentic AI; not to be confused with workflows.

“Agentic” is the adjective, and one of the most overused words of the moment. It gets applied just as readily to a genuinely autonomous agent as to a simple chatbot with a button.

In reality, autonomy isn’t a checkbox, it’s a slider.

In late 2024, Anthropic proposed a useful distinction:

The most autonomous isn’t always the best.

A well-designed workflow is more reliable, cheaper and easier to audit than an agent, and it’s enough for many repetitive tasks. An agent earns its place when the path can’t be written in advance.

Harness, sometimes scaffolding: the program that runs the agent.

Who runs the loop? Not the model: it only predicts text.

It’s the harness that:

• assembles the desk (what goes on it, what gets summarised when it overflows)
• runs the tools
• enforces the permissions
• asks for your approval when needed
• decides when to stop

Remember the engine and the car from Part 1? The harness is an agent’s car. Claude Code, Codex, Cursor, Gemini CLI and ChatGPT’s agent mode are each, in their own way, harnesses built around one or more models.

The same engine doesn’t deliver the same performance inside different bodywork: a good share of an agent’s quality comes down to its harness.

Model Context Protocol: a protocol that supplies context to models.

Plugging in tools is great. But every AI application had its own way of doing it. To connect four assistants to four pieces of company software, you needed sixteen connectors, each written and maintained by hand. In November 2024, Anthropic published an open standard to end this headache: the Model Context Protocol, or MCP.

That software can be a ticketing tool, a messaging app, a storage service, a database, your in-house tool. And the standard caught on very fast:

1. 2024
   Release

   In November, Anthropic publishes the open standard.

2. 2025
   Adoption, then a foundation

   OpenAI adopts it in March; Google and Microsoft follow, along with most developer tools. In late 2025, Anthropic hands its governance to a foundation hosted by the Linux Foundation.

3. 2026
   The reference plug

   It has become the standard for plugging tools into an AI.

Agent Skills; and their cousins: instruction files, commands, plugins.

MCP provides the hands. It doesn’t provide the know-how.

That kind of knowledge is about internal procedures, and it’s what skills carry.

Anthropic launched the format in October 2025, then published it as an open standard; other tools have adopted it since. Typical examples:

• Write meeting minutes in the company format
• Produce a spreadsheet following the style guide
• Prepare a production release

The trick lies in how the agent consults them, and it follows directly from the desk’s limited size:

1. At startup, the agent reads only the name and one-line description of each skill: a few dozen tokens each.

2. It opens the full instructions only when the task calls for them.

So you can give it dozens of skills without cluttering its desk. This is called progressive disclosure.

---
name: release
description: Checks and deploys a new version.
---
# Production release
1. Run all the tests; stop at the first failure.
2. Review the changelog with the human.
3. Never deploy on a Friday after 4 pm.
4. After deploying, watch the home page
   and the error dashboard for 10 minutes.

Alongside skills, you’ll come across a few cousins:

The names vary from one tool to the next; the idea is always the same: write down once what you’d otherwise repeat every time.

Sub-agents, multi-agent systems, orchestration.

When a mission is large, a single desk is no longer enough. Hence the idea of delegating.

The orchestrator keeps a clear desk, and the subagents can work in parallel.

And coordination has its hiccups, as in any team:

• work done twice
• instructions lost in transmission
• summaries that miss the key point

So that agents from different vendors can talk to each other, Google proposed another standard in April 2025, A2A (Agent2Agent).

Computer use, browser agents.

And when a piece of software has neither an API nor an MCP server? You give the agent the screen itself. Some models can now look at a screenshot, spot a button, decide where to click and what to type.

1. 2024
   Anthropic leads the way

   In October.

2. 2025
   Operator, then ChatGPT’s agent mode

   OpenAI follows in January with Operator, then with ChatGPT’s agent mode.

Human in the loop, permissions, sandbox, prompt injection, evals.

The more hands an agent has, the more concrete security becomes.

The vocabulary of agent security comes down to six notions.

Prompt injection deserves a closer look, because it follows directly from everything we’ve seen: to the model, everything on the desk is text, and it struggles to tell its user’s orders apart from sentences it reads in a document.

The problem remains unsolved to this day: we contain it by limiting what the agent can do, and by keeping a human before the actions that matter.

Time to climb back up. From above, the dozens of words we met along the way draw a single figure, much simpler than it looked at the start. But first, a promise to keep.

The meeting sentence, decoded

Let’s take the project manager’s proposal again, piece by piece.

• What if we plugged an agenta model that uses tools in a loop to carry out a mission, driven by a harness.Part 4
• into our document base, with RAGbefore answering, it searches our documents by meaning for the useful passages and puts them on its desk.Part 3
• connected to Jira via MCPthe ticketing tool is plugged into the standard socket: the agent can read and create tickets.Part 4
• with a good system promptthe house’s standing instructions: role, tone, rules, limits.Part 3
• and two or three skillshow-to guides for our procedures, which the agent opens only when it needs them.Part 4
• it would fit in the context windowthe whole thing wouldn’t exceed the size of the desk, measured in tokens.Part 3
• and we’d limit hallucinationsby relying on our documents rather than on its memory, it would make things up less often. Less often, not never.Part 2

It’s a good idea. And now you know which questions to ask before nodding along:

The whole map

And here is the complete map, in a single picture. In Part 1, the Russian dolls told us what an LLM is. These ones tell us how we build, around it, an AI that acts. All the jargon in this article fits into these five layers.

The pocket glossary

To finish, the promised glossary, arranged not in alphabetical order but in the order of the map. Each word fits on one line; if a line no longer rings a bell, the matching part is there for that.

What will change

If these three sentences now seem obvious to you, tomorrow’s words will find their own place on your map.