Glossary · Chapter 02
The leap from automation to autonomy starts with a different kind of software: systems that are not programmed but trained. Machine learning entered automation quietly at first — as a document reader, a classifier, a forecasting model. With large language models (LLMs), from 2022 onwards, came the ability to process language, context and intent. This chapter explains how these systems work, where their limits are — and why you should never trust them unsupervised.
The umbrella term for systems that solve tasks commonly thought to require human intelligence: understanding, reasoning, planning, learning. In practice, “AI” is almost always machine learning — software whose behaviour was learned from data rather than hand-written as rules. Important for any serious discussion: AI is not one technology but a spectrum — from the spam filter to the language model.
Training · inference
Instead of giving a program rules, you show it examples. During training, an algorithm builds a statistical model from thousands of examples (say: invoice + correctly extracted fields). During inference, the finished model applies what it learned to new cases. The fundamental difference from classic automation: the behaviour is learned and probabilistic — there is no line of code containing “the rule”, and no guarantee, only probabilities.
The model family behind nearly every recent AI breakthrough: networks of millions to billions of simple computing units (“neurons”), stacked in layers. Each layer turns its input into a more abstract representation — pixels become edges, edges become shapes, shapes become objects. Deep learning just means: many layers. The bigger the network and its training data, the more capable the model — an observation that, as a scaling law, has driven the last decade of AI progress.
A very large neural network, trained on a substantial share of all text ever written, with a deceptively simple task: predict the next word. From this task, practised billions of times, something remarkable emerges — the ability to understand language, recall knowledge, reason and follow instructions. LLMs are the engine of agentic systems: they supply the understanding of language and the world that classic automation always lacked.
Today's leading models are then trained further with reinforcement learning: they think in intermediate steps before answering, check approaches and correct themselves. That makes them far stronger at logic, code and multi-step tasks – but not error-free, and every reasoning step costs time and tokens.
Just as important is what an LLM is not: not a database, not a calculator, not a source of guarantees. It produces plausible answers — which is why enterprise use demands evidence, checks and limits.
The prompt is everything the model gets to see for a task: instruction, role, rules, examples, documents. The context window is the maximum amount of it — the model's short-term memory. Whatever is not in the context does not exist for the model in that moment. Leading models now hold a million tokens or more – but less of that is used reliably, as accuracy measurably drops with longer inputs. In agentic systems the discipline is therefore called context engineering: which data, rules and tools does the agent get to see, and when – and what stays out?
When a language model states something false with full confidence: an invented invoice number, a court ruling that does not exist, a plausible but wrong figure. Hallucinations do not disappear completely: for rarely documented facts, training itself inevitably produces errors, and many tests reward guessing over “I don't know” — models that think before answering are not immune either. The professional response: tie statements to sources (RAG), check outputs mechanically (evals, a verify step) and have humans approve critical decisions.
The most common answer to hallucinations and stale model knowledge: before the model answers, the system retrieves the relevant passages from your documents — contracts, handbooks, tickets — and places them in its context. The model then answers based on that evidence and can cite it. RAG turns a generally educated model into a system that knows your reality — without training a model to get there.
RAG reduces errors but does not eliminate them — it makes statements verifiable. With agents, retrieval is increasingly a tool the agent calls on purpose.
Two ways to adapt a model to a task. Prompting (with RAG and examples) changes nothing about the model — fast, cheap, instantly correctable. Fine-tuning continues training the model on your own data — more expensive, slower to iterate, but able to shape tone, special formats and narrowly defined tasks — for instance to make a smaller, cheaper model as good as a large one there. The enterprise rule of thumb: prompting and RAG first; fine-tuning only when demonstrably necessary. Most “we need our own model” projects actually need better prompts and better retrieval.
Software testing for probabilistic systems: a collection of real cases with known correct outcomes, against which the system is checked automatically — after every prompt change, every model update, before every release. Without evals, any claim about an AI system's quality is a gut feeling. With them, “the model seems good” becomes a measurement: 96.4% correct on 1,200 real cases, no regression against last week. To us, the core of serious agent engineering.
With agents, the final answer is not enough: the path is assessed too — which tools were called with which values, whether limits were kept — as well as the actual end state in the system. Because the same case can turn out differently, every test runs several times; where there is no unambiguous result, a second model often grades, and it must be calibrated against human judgement regularly.