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.
Just as important is what an LLM is not: not a database, not a calculator, not a source of guarantees. It produces plausible continuations — 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. In agentic systems, prompt design is therefore engineering, not wordsmithing: which data, rules and tools does the agent get to see, and when?
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 are not a bug that will disappear but a property of the technology — the model optimises for plausibility, not truth. The professional response: tie statements to sources (RAG), check outputs mechanically (evals, a verify step) and have humans approve critical decisions.
The standard 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.
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 and special formats. 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.