The vocabulary of AI travels in English, and its French translations are either missing or too formal to say out loud. This glossary gives both: the English term, the French term, and the definition as it actually matters when you're building something.
Definitions favour working usage over official terminology. Every entry points to a source that goes deeper: the founding paper, reference documentation, or an encyclopedic overview.
Foundations 10
The machine learning vocabulary that sits underneath language models.
Artificial intelligence (AI)
Intelligence artificielle (IA)
Umbrella term for systems that perform tasks we used to associate with human reasoning. In practice, when someone says "AI" today they almost always mean machine learning applied to large models. The word is too broad to be useful in design: always ask which model and which task.
Machine learning
Apprentissage automatique
Also called machine learning
An approach where the program's behaviour is derived from data rather than written by hand. You don't code the rules; you supply examples and an objective to optimize. Direct consequence for a developer: behaviour is no longer readable in source code, it's encoded in numeric parameters.
Deep learning
Apprentissage profond
A subset of machine learning built on neural networks with many layers. Depth lets the model build its own intermediate representations instead of relying on human-chosen features. This is what made language and image processing work at today's scale.
Neural network
Réseau de neurones
A mathematical function made of layers of simple units, each combining its inputs with weights and applying a non-linearity. Nothing biological about it despite the name: it's stacked linear algebra. Its strength is approximating very complex functions given enough parameters and data.
Transformer
Transformeur
Also called transformer
A neural network architecture published by Google in 2017 that processes a whole sequence in parallel through attention rather than word by word. It's the architecture behind virtually every current language model. The "T" in GPT.
Go deeper Vaswani et al. — Attention Is All You Need (arXiv)
Attention
The mechanism by which the model weighs how much each token in the context matters while processing a given token. It's what lets it connect a pronoun to its antecedent thirty lines earlier. Its cost grows with the square of context length — which is why very large context windows are expensive.
Parameter
Paramètre
A numeric value learned during training. Parameter count (7 billion, 70 billion…) gives a rough sense of a model's capacity and of the memory needed to run it. It is not a quality metric: a small, well-trained model often beats a large, poorly trained one.
Weights
Poids
The parameters of a neural network, seen as the file you download and load into memory. "A model's weights" is concretely its knowledge: two models with the same architecture and different weights are two different models. It's also what openness debates are about — publishing the weights is publishing the model.
Embedding
Plongement vectoriel
Also called embedding
A representation of a text, image, or token as a vector of numbers, built so that geometric closeness reflects closeness in meaning. It's the building block of semantic search and RAG: you compare vectors, not words.
Go deeper Google — Embeddings (Machine Learning Crash Course)
Overfitting
Surapprentissage
When a model memorizes its training data so well that it generalizes poorly to new data. Great training scores, poor production behaviour. The agentic version of the problem: a prompt tuned to perfection on your twenty test cases that collapses on the twenty-first.
Models 9
What we call "a model", and the families worth telling apart.
Model
Modèle
A file of weights plus the code that knows how to run it. From a developer's seat it's a function: you pass text, it returns text, with no state between calls. Anything that looks like memory — conversation history, open files, tool results — is re-sent to the model on every call by the code around it.
Go deeper Wikipedia — Foundation model On this site What's Really Happening When You Talk to an AI
Large language model (LLM)
LLM
Also called grand modèle de langage
A model trained on huge text corpora to predict the next token. Everything else — answering a question, writing code, summarizing — falls out of that single task. Remembering this prevents a lot of bad intuitions: the model isn't looking for truth, it's looking for a plausible continuation.
Go deeper Wikipedia — Large language model On this site What's Really Happening When You Talk to an AI
Foundation model
Modèle de fondation
A general-purpose model trained at scale, meant to be adapted to many downstream tasks rather than one. The term comes from Stanford in 2021 and stresses an economic property: training costs tens of millions, adapting costs little.
Go deeper Stanford CRFM — On the Opportunities and Risks of Foundation Models
Frontier model
Modèle frontière
The most capable model available at a given moment, usually the largest and most expensive of its family. The term is used as much in marketing as in policy, where it means models powerful enough to warrant specific oversight. Technically "frontier" is a ranking position, not a property of the model — and the position changes every few months.
Go deeper Anderljung et al. — Frontier AI Regulation (arXiv)
Reasoning model
Modèle de raisonnement
A model trained to produce a long internal chain of thought before its final answer, and to spend more compute at inference time when the problem is hard. Better at math, code, and planning; slower and more expensive. Save it for tasks where reasoning is the bottleneck, not for rewriting an email.
Multimodal model
Modèle multimodal
A model that accepts or produces several data types — text, image, audio, video — in a shared representation space. In agentic practice, it's what lets an agent read a screenshot, a diagram, or a scanned PDF instead of demanding clean text.
Open-weights model
Modèle à poids ouverts
A model whose weights are published and runnable on your own infrastructure. Not the same thing as "open source": training data and training code often stay closed, and the licence may restrict use. The practical appeal: data control, predictable cost, no API dependency.
Distillation
Training a small model to imitate the outputs of a large one. You trade a little capability for a lot of speed and cost. It's where most of the small, fast models you use for classification or routing come from.
Go deeper Hinton et al. — Distilling the Knowledge in a Neural Network (arXiv)
Quantization
Quantification
Also called quantization
Reducing the numeric precision of the weights — from 16 bits down to 8 or 4 — so a model fits on more modest hardware. Quality drops a little, memory drops a lot. It's what makes running a serious model on a laptop possible.
Training 7
How a model acquires — and loses — its capabilities.
Pre-training
Préentraînement
The long, expensive phase where the model learns language by predicting the next token across terabytes of text. It produces a model that can continue text but can't yet follow an instruction — that's the job of the later phases.
Go deeper Brown et al. — Language Models are Few-Shot Learners (arXiv)
Fine-tuning
Also called réglage fin, ajustement
Continuing training of an existing model on a specific dataset to give it a particular behaviour, format, or tone. Useful for form, rarely for facts: when the information changes, putting it in the context via RAG is almost always the right move.
Go deeper Wikipedia — Fine-tuning (deep learning) On this site Fine-Tuning vs. RAG: When to Teach the Model and When to Show It the Answer
LoRA (low-rank adaptation)
LoRA
A fine-tuning technique that freezes the original weights and trains only a small set of additional matrices. You go from billions of parameters to tune down to a few million: training fits on a single GPU, and several swappable adapters can share one base model.
RLHF (reinforcement learning from human feedback)
RLHF
Also called apprentissage par renforcement à partir de rétroaction humaine
The phase where humans rank model responses, a reward model learns their preferences, and the model is then optimized against that reward. It's what turns a completion engine into a useful assistant — and also why it tends to agree with you.
Go deeper Ouyang et al. — Training language models to follow instructions (arXiv)
Alignment
Alignement
The set of techniques aimed at making a model's behaviour match the intentions and values of those deploying it. Concretely, it's what produces refusals, caveats, and behavioural limits. An aligned model isn't a safe model: it's a model whose failures are more predictable.
Training data
Données d'entraînement
The corpus from which the model draws everything it knows. Its composition explains the biases, gaps, and strengths you see in use — a model fed mostly Python will be better at Python. It's also where copyright and privacy questions land.
Knowledge cutoff
Date de coupure des connaissances
The date after which the model has seen nothing. Anything newer — a library version, an API, a news event — has to be handed to it in the context. Asked about the post-cutoff world, a model doesn't say "I don't know": it invents something plausible.
Go deeper Cheng et al. — Dated Data: Tracing Knowledge Cutoffs (arXiv)
Tokens and context 9
The billing unit, the memory unit, and the constraint that governs everything else.
Token
Jeton
Also called token
The unit the model reads and writes: a fragment of a word, not a character and not a whole word. In English, roughly four characters per token; in French, a bit less, because of accents and longer words. It's the billing unit, the context-window unit, and the latency unit — so it's the unit that matters.
Tokenization
Tokenisation
Also called segmentation en jetons
The step that splits your text into tokens before the model ever sees it. It's why a model miscounts the letters in a word: it doesn't see letters. Most odd behaviour around digits, URLs, or rare characters starts here.
Context window
Fenêtre de contexte
The maximum number of tokens the model can take into account in a single call: system prompt, history, documents, tool results, and the answer being written, all included. It's a budget, not storage. And attention across it isn't uniform: material in the middle of a very long context is used less well than material at the start or the end.
Go deeper Liu et al. — Lost in the Middle (arXiv) On this site Context Is Finite. Program Accordingly.
Compaction
Replacing a conversation history that has grown too long with a summary, so work can continue without overflowing the window. It's lossy: whatever isn't in the summary is gone. In a long agentic session, that's often the moment an agent "forgets" a constraint you set at the start.
Go deeper Anthropic — Effective context engineering for AI agents On this site Context Is Finite. Program Accordingly.
Prompt caching
Mise en cache de prompt
Reusing the computation already done on an identical context prefix from one call to the next instead of redoing it. Cost and latency drop sharply on stable prefixes. The practical consequence: put what doesn't change — instructions, documentation, schemas — at the start of the prompt, and what varies at the end.
Inference
Inférence
Running the model on an input to produce an output — as opposed to training, which changes the weights. Every API call is an inference. It's where your application's day-to-day latency, cost, and energy footprint are actually paid.
Temperature
Température
The parameter that controls how random the next-token draw is. Near zero, the model always takes the most likely token — stable, more repetitive output. Higher, it explores — more varied, less reliable. For extraction or code, keep it low.
Sampling (top-p, top-k)
Échantillonnage
The strategy for picking the next token among likely candidates. Top-k restricts the draw to the k best, top-p (nucleus) to the candidates covering p% of the probability mass. Along with temperature, these are the three dials that decide whether your system is boring or unpredictable.
Go deeper Holtzman et al. — The Curious Case of Neural Text Degeneration (arXiv)
Streaming
Also called diffusion en continu
Returning the response token by token as it is generated rather than as one final block. Total time doesn't change; time to the first visible character does. It's a user-experience decision before it's an infrastructure one.
Prompting 6
What you write to the model, and how you write it.
Prompt
Also called invite
The text sent to the model to obtain a behaviour. In an agentic system it isn't a question typed on the fly: it's an artifact that gets versioned, tested, and reviewed like code, because it's what determines how the system behaves.
System prompt
Prompt système
The instructions placed at the head of the context, defining the role, constraints, and expected format for the whole conversation. The model weighs them more heavily than ordinary messages, but they aren't a security boundary: hostile content in the context can contradict them.
Prompt engineering
Also called ingénierie de prompt
The practice of structuring the input to get reliable behaviour: role, examples, output format, explicit constraints, and above all what not to do. Less magic than specification — most bad results come from an ambiguous instruction, not a weak model.
Go deeper DAIR.AI — Prompt Engineering Guide On this site Advanced Prompt Engineering: Beyond the Basics
Zero-shot / few-shot
Also called sans exemple / à quelques exemples
Asking for a task with no examples (zero-shot) or with a few examples placed in the prompt (few-shot). Examples usually beat a long paragraph of explanation, especially for pinning down an output format. Careful: this isn't fine-tuning, nothing is learned — the examples are re-sent on every call.
Go deeper Brown et al. — Language Models are Few-Shot Learners (arXiv)
Chain of thought
Chaîne de pensée
Getting the model to write its reasoning step by step before its conclusion. It improves multi-step tasks, and above all it gives you a readable trace: when the answer is wrong, you can see where the reasoning drifted. The displayed reasoning is still model output, not a faithful account of its computation.
Extended thinking
Raisonnement étendu
A mode where the model is given a token budget dedicated to thinking before it answers. Different from chain-of-thought asked for in the prompt: here the budget is a call parameter, and the thinking tokens are billed. Useful when decision quality matters more than latency.
Agents and harnesses 14
What turns a model that answers into a system that acts.
Agent
A system where a model itself decides which actions to chain toward a goal, using tools and the results of its previous actions. The useful distinction isn't "agent or not" but "who decides the next step": if it's your code, it's a pipeline; if it's the model, it's an agent.
Agentic
Agentique
Describes a system whose control flow isn't fixed in advance but decided by a model at run time. The word marks a slider rather than a category: the more the system picks its own steps, the more agentic it is — and the more guardrails and observability it needs.
Harness
Harnais
All the code around the model: the call loop, context management, the exposed tools, permissions, retries, and logs. The model is swappable; the harness is your product. It's where two assistants running the very same model end up different.
Go deeper Anthropic — Building agents with the Claude Agent SDK
Agent loop
Boucle d'agent
The fundamental cycle: the model observes the context, picks an action, the harness executes it, the result goes back into the context, and round it goes until a stopping condition. An agent's reliability rests entirely on that stopping condition and on what you put back into the context each turn.
Tool
Outil
A function the model can ask to have executed — read a file, query a database, call an API. Its description is a prompt: a precise name and clear documentation improve agent behaviour more reliably than a bigger model does.
Tool call (function calling)
Appel d'outil
The structured output through which the model requests a tool with its arguments. The model executes nothing itself: it produces an intent, and your code decides whether to honour it. That's exactly where permission checks belong.
Skill
A bundle of instructions, scripts, and resources an agent loads on demand when a task calls for it. The idea is to keep the context light by default: instead of putting everything in the system prompt, you describe the capability in one line and load the detail only when it's needed.
MCP (Model Context Protocol)
MCP
An open protocol standardizing how an agent connects to external data sources and tools. The appeal is the same as LSP for editors: an MCP server written once works with every compatible client, instead of one integration per product.
Subagent
Sous-agent
An agent launched by another agent with a bounded task and its own context. The main benefit isn't parallelism but context isolation: the subagent explores, reports a conclusion, and the noise of its exploration never lands in the main context.
Go deeper Anthropic — How we built our multi-agent research system On this site Multi-Agent Architectures: When One Agent Isn't Enough
Orchestration
Coordinating several models, tools, or agents: who does what, in what order, on what budget, and what happens on failure. It's ordinary plumbing — queues, retries, idempotency — and it deserves to be treated as such rather than handed to a model.
Go deeper Anthropic — Building effective agents On this site Multi-Agent Architectures: When One Agent Isn't Enough
Human in the loop
Humain dans la boucle
A checkpoint where a person approves before an action happens. Put it where the action is hard to undo — sending an email, deleting data, deploying to production — and nowhere else, or approval becomes a reflex and stops protecting anything.
Guardrails
Garde-fous
Deterministic controls placed around the model: schema validation, allowlists, spending caps, output filters. A guardrail implemented as an instruction in the prompt isn't one — it has to live in code the model cannot talk its way past.
Sandbox
Bac à sable
An isolated environment where the agent runs code and commands without reaching the rest of the system. Restricted filesystem, controlled network, limited credentials. It's the only protection that holds when the agent runs code it just wrote itself.
Memory
Mémoire
Any mechanism that persists information across model calls, since the model itself keeps none. Files, a database, session summaries, structured notes: it's always storage plus a decision about what to read back. An agent has exactly the memory you build for it.
Retrieval and memory 6
Giving the model access to knowledge it never learned.
RAG (retrieval-augmented generation)
RAG
Also called génération augmentée par récupération
Retrieve the documents relevant to the question, then place them in the context before asking for the answer. It's the default choice when information changes, is private, or must be cited. A RAG system's quality is decided almost entirely in the retrieval step, not in the model.
Go deeper Lewis et al. — Retrieval-Augmented Generation (arXiv) On this site RAG: What It Is and How to Actually Use It
Vector database
Base de données vectorielle
A database specialized in storing embeddings and searching nearest neighbours. Useful at scale; often unnecessary below a few tens of thousands of documents, where a plain index — or straightforward full-text search — does the job for less.
Chunking
Découpage
Also called chunking
Splitting documents into fragments before indexing them. Fragment size and boundaries decide what retrieval can ever find: a chunk that cuts a table in half makes that table useless. It's the highest-leverage knob in a RAG system.
Go deeper Pinecone — Chunking strategies On this site RAG: What It Is and How to Actually Use It
Semantic search
Recherche sémantique
Searching by closeness of meaning in embedding space rather than by keyword match. It finds a document that uses none of the question's words — and sometimes misses an obvious exact match. In practice you combine it with lexical search.
Reranking
Reclassement
A second pass that reorders the candidates returned by search using a more accurate but more expensive model. Retrieve broadly, rerank tightly, keep only the top of the list in the context. Often the best effort-to-quality ratio for improving an existing RAG system.
Go deeper Nogueira & Cho — Passage Re-ranking with BERT (arXiv)
Grounding
Ancrage
Constraining the answer to rest on supplied sources, and making that support checkable through citations. A well-grounded system has to be able to say "it isn't in the documents" — without that exit, it will fill the gap by inventing.
Go deeper Rashkin et al. — Measuring Attribution in NLG (arXiv)
Evaluation and reliability 10
How to know whether it works, and how it breaks.
Eval
Éval
Also called évaluation
A set of test cases built for a system whose outputs have no single right answer. It's the equivalent of a test suite in ordinary development: without one, you have no way to know whether your prompt change improved things or broke three others.
Go deeper Stanford CRFM — HELM (Holistic Evaluation of Language Models) On this site Evals: How to Test Systems That Don't Have Right Answers
Benchmark
Banc d'essai
Also called benchmark
A standardized task set used to compare models. Useful for narrowing a choice, insufficient for deciding: a model topping a public leaderboard can be mediocre on your domain, and test-set contamination is a real problem.
Hallucination
Output that is fluent, confident, and wrong. It isn't a bug to be fixed but a property of the process: the model produces the most plausible continuation, and plausible isn't true. You don't eliminate it, you contain it — grounding, citations, automated verification.
Go deeper Ji et al. — Survey of Hallucination in NLG (arXiv)
LLM-as-judge
LLM juge
Using a model to score another model's outputs against a rubric. It's what makes evaluation possible at scale on subjective tasks. The judge has its own biases — position, length, style — which you have to measure against a human-scored sample.
Go deeper Zheng et al. — Judging LLM-as-a-Judge (arXiv) On this site Evals: How to Test Systems That Don't Have Right Answers
Golden dataset
Jeu de référence
A set of examples whose expected output has been validated by humans, used as the yardstick for every later evaluation. Building one is tedious and it's the best investment in an AI project: it's what turns "feels better" into a measurement.
Determinism
Déterminisme
The property of a system that returns the same output for the same input. A model call isn't deterministic by default, and even at zero temperature variation remains. It's an architectural decision: whatever must be reproducible — validation, computation, side effects — belongs in your code, not in the model.
Observability
Observabilité
The ability to reconstruct after the fact what a system did and why. For an agent that means tracing every call: full prompt, tools invoked, arguments, results, tokens consumed. Without that trace, debugging non-reproducible behaviour is impossible.
Prompt injection
Injection de prompt
An attack where content the agent processes — a web page, an email, a ticket, a file — carries instructions the model follows as if they came from you. The model doesn't separate data from instructions. It's the structural vulnerability of agentic systems: all external content is untrusted input.
Jailbreak
Also called contournement
A phrasing designed to push a model past the limits set by its alignment. Different from prompt injection: here the user attacks the model, rather than a third party hijacking the agent. Both are handled in the same place — in the surrounding code, not in the prompt.
Go deeper Zou et al. — Universal and Transferable Adversarial Attacks (arXiv)
Drift
Dérive
Gradual performance decay as real-world data drifts away from what the system was tuned on — or as the provider updates the model underneath you. A prompt that worked six months ago may not work today without a single line of your code having changed.
Operations 4
The constraints that decide whether a prototype becomes a product.
Latency / TTFT
Latence / TTFT
The delay between request and response. For a model, two measures matter: time to first token (TTFT), which governs perceived speed, and generation throughput after that. An agent chaining ten calls multiplies the delay by ten — latency is an architectural constraint, not an infrastructure detail.
Throughput
Débit
Volume processed per unit of time — tokens per second, requests per minute. It usually trades against latency: batching improves throughput and worsens individual response time. Decide which one you're optimizing before you size anything.
Rate limit
Limite de débit
A provider-imposed ceiling on requests or tokens per interval. A looping agent hits it faster than a conventional application does. Treat it as a normal operating mode — exponential backoff, queueing, graceful degradation — not as an exceptional error.
Cost per token
Coût par jeton
The billed price, separate for input and output, usually per million tokens. An agent that re-reads its whole history each turn has a cost quadratic in the number of turns. Cost is a design parameter just like latency: you work it out before writing the loop, not after the first invoice.
No term matches.