A model wired to take actions — calling tools, browsing, writing code — to pursue a goal.

A system in which an LLM does not merely answer but plans and acts: calling tools, reading results and iterating toward a goal across many steps. Built on function calling, connected via standards like MCP, and coordinated by orchestration.

The observe–think–act–repeat cycle an agent runs until a task is done.

The control cycle at the heart of every agent: the model reads the current state, decides on an action, the harness executes it via function calling, the result is fed back, and the loop repeats until the goal is met or a limit is hit. Reasoning quality, stopping conditions and error recovery within this loop largely determine whether an agent is reliable.

A central team that sets standards and accelerates AI delivery across a business.

A hub that concentrates scarce AI talent, reusable tooling and standards — security, evaluation, governance — so individual teams ship faster and more safely. Part of the broader AI operating model; effective where it enables delivery rather than becoming a bottleneck.

The policies and controls that keep AI use safe, compliant and accountable.

The framework of standards, approvals, red teaming and audit that defines what AI may be used for and how risk is managed. Done well it enables responsible scale rather than blocking it, and it is the legitimate alternative to ungoverned shadow AI.

A banded framework — typically Nascent to Transformational — for grading AI capability.

A scoring rubric that places an organisation on a five-band ladder from nascent curiosity to industrialised, governed AI. Each band carries a recommended next move, so the assessment ends as a roadmap rather than a grade. Used as the backbone of any AI readiness assessment and the language by which leadership tracks progress year-on-year.

How an organisation structures ownership, delivery and control of AI.

The arrangement of people, process and accountability that turns strategy into shipped systems: who funds use cases, who builds, who reviews, and where a human stays in the loop. It spans a centre of excellence, embedded teams and the governance that keeps autonomy inside agreed limits.

A structured diagnostic of whether an organisation can adopt and sustain AI.

The step-zero exercise in any serious enterprise AI strategy: a questionnaire and interview programme that scores foundations — leadership, data readiness, technology, skills, operating model, governance, responsible AI and adoption — against an AI maturity model. The output to act on is the per-dimension profile, not the headline score; the spiky shape is where the first roadmap comes from.

The problem of making capable systems pursue their operators' actual intent.

The discipline of ensuring AI systems do what their designers and users actually want — safely, honestly and helpfully — as capability grows. Approached through RLHF, Constitutional AI, interpretability and red teaming.

A hypothetical system matching or exceeding human ability across essentially all cognitive tasks.

The field's long-horizon goal: a single system that meets or beats human performance across the full breadth of cognitive work, not just narrow domains. There is no agreed test for it. Progress is tracked through benchmarks and the trajectory implied by scaling laws.

The umbrella term for machines that perform tasks once thought to require human intelligence.

The broadest term in the field: software that performs tasks — perception, reasoning, language, decision-making — once assumed to require a human mind. Today's headline systems are a narrow slice of this, built almost entirely on machine learning and, more specifically, deep learning. The far horizon, a system matching humans across the board, is artificial general intelligence.

The mechanism that lets a model weigh which other tokens matter when processing each one.

The core operation of the transformer: for every token, the model computes how much to draw on every other token in the context window. "Self-attention" does this within a single sequence. It is powerful but costly, which is why long contexts lean on the KV cache.

The algorithm that assigns credit for error back through every layer of a network.

The method for efficiently computing how every weight in a neural network contributed to its error, so gradient descent knows how to adjust them. The mathematical backbone of deep learning.

A standard test used to compare models on a defined task.

A fixed dataset and scoring method used to rank models on a capability. As models improve, benchmarks saturate and the field moves the goalposts — currently to GPQA, SWE-bench and composite indices.

Systematic skew in a model's outputs, usually inherited from its training data.

Systematic and often unfair patterns in a model's behaviour, typically reflecting imbalances in its training data. A central concern of alignment, evaluation and responsible deployment.

The decision to develop AI capability in-house or adopt a vendor's.

The recurring choice between building on raw models — including open weights you host and fine-tune — and buying a finished product. The honest answer is usually a mix: buy the commodity layer, build only where proprietary data or workflow creates real advantage, and keep the architecture model-agnostic so the decision can be revisited as prices fall.

The quantified argument that an AI initiative returns more than it costs.

The financial justification for an initiative, tying it to a single measurable number — downtime avoided, hours saved, conversion lifted — net of its total cost of ownership. A credible case names the owner of that number and a realistic time-to-value; the most common failure is a pilot with impressive demos and no P&L line.

Prompting (or training) a model to reason step by step before answering.

A technique in which a model is induced to lay out intermediate reasoning before its final answer, markedly improving performance on hard problems. Taken further with reinforcement learning, it produces dedicated reasoning models.

The people-side work of getting an organisation to actually adopt AI.

The effort of retraining, redesigning roles and winning trust so a deployed system is used and relied upon. Technology is rarely the binding constraint; adoption is. It belongs in every business case and is a core remit of the operating model.

A model offered only as a service, with weights kept proprietary.

A model whose weights are not released; access is sold via API or product, as with the flagship offerings of the leading labs. The commercial alternative to open weights, trading control for accessibility.

A large array of interconnected accelerators that trains a frontier model together.

Tens of thousands of GPUs or TPUs lashed together with high-speed networking to act as one machine for a training run. Building and powering them is the central infrastructure story of the AI build-out.

The best balance of model size and data for a fixed compute budget.

The insight — formalised by the "Chinchilla" work — that for a given compute budget there is an optimal trade-off between parameter count and training data, and that many early models were oversized and under-trained. A practical corollary of scaling laws.

Aligning a model to an explicit written set of principles rather than case-by-case labels.

An alignment method, pioneered at Anthropic, in which a model critiques and revises its own outputs against a written "constitution" of principles, reducing reliance on human labelling. A practical form of RLAIF.

Deciding what goes into the context window — instructions, retrieved data, memory, tools.

The discipline, broader than prompt engineering, of assembling everything a model sees on a given call: the system prompt, retrieved documents, conversation memory, tool definitions and intermediate results — all within the limits of the context window. In agentic systems the harness does this dynamically every turn, and doing it well is often the difference between a capable agent and a confused one.

The maximum amount of text a model can consider at once, measured in tokens.

The span of tokens a model can attend to in a single pass — its working memory. Frontier windows now reach into the millions of tokens, though attention quality can thin out across very long contexts. Serving long windows is what the KV cache exists to make affordable.

The unit price of using a model, billed per token in and out.

The prevailing pricing model for AI: a fee per thousand or million tokens processed, usually split between input and output. Frontier prices have fallen sharply, pressured by open weights, distillation and mixture-of-experts efficiency.

Whether your data is good enough, accessible enough and governed enough to train or ground AI on.

The honest state of the asset every AI system stands on: quality, coverage, lineage, access rights and the system of record that owns each domain. Weak data readiness is the most common binding constraint surfaced by an AI readiness assessment — and the reason early effort often belongs in data plumbing, not in models.

Machine learning using many-layered neural networks.

A branch of machine learning that stacks many layers of a neural network so the system learns increasingly abstract features of its data. It is the engine behind virtually every capability discussed in this publication, from image generation to the transformer.

A generative model that creates images (or video) by iteratively denoising random noise.

The architecture behind most image and video generation: it learns to reverse a noising process, turning random static into a coherent picture over many steps, guided by a text prompt. Distinct from the transformer lineage that dominates language, though the two increasingly blend.

A live virtual model of a physical asset, line or plant, fed by real-time data.

A continuously updated digital replica of equipment or a process, used to simulate, monitor and optimise it. In manufacturing it is increasingly paired with agents that read its signals to drive predictive maintenance and scheduling.

Training a small, cheap model to mimic a large, capable one.

Compressing capability by training a compact "student" model to reproduce the outputs of a larger "teacher". It is how labs ship fast, inexpensive models that approximate their flagships, and a lever on cost per token.

The silent decay of model quality as inputs, the world or the model itself shift over time.

A divergence — in input distribution, output quality or downstream metrics — from the baseline you launched on. Drift is the canonical silent failure of generative systems: nothing crashes, the model just gets a little less right. The defence is continuous observability, a drift indicator with a threshold, and a golden dataset that grows after every incident.

A list of numbers representing a piece of data, where closeness means similarity in meaning.

A vector — a list of numbers — that places a token, sentence or image in a high-dimensional space where geometric closeness corresponds to similarity of meaning. Embeddings are the lingua franca inside a model and the basis of retrieval-augmented generation and the vector database.

Two transformer roles: encoders read and represent input; decoders generate output.

Two architectural roles. An encoder reads a sequence into rich embeddings; a decoder generates a sequence one token at a time. Most chat LLMs are decoder-only; translation and some multimodal systems use both.

The plan by which an organisation turns AI capability into durable, owned business value.

The discipline of deciding where AI is applied, who owns the outcome and how value is captured and defended — as distinct from running experiments. A sound strategy starts from the business problem, leans on use-case prioritisation, a deliberate operating model and a model-agnostic posture, because capability is converging and price is falling. The durable asset is rarely the model; it is the proprietary data, the workflow and the trust around it.

Any structured test of model capability, safety or reliability.

Shorthand for an evaluation — a structured measurement of a model's performance, whether a public benchmark or a private, task-specific test suite. Building good evals is now a discipline in itself, and the guard against overfitting to the famous ones.

Further training of a pretrained model to specialise it or align its behaviour.

Continuing to train a pretrained model on a smaller, targeted dataset to specialise it for a domain or to shape its behaviour. Modern assistants are fine-tuned for helpfulness using RLHF; efficient variants use LoRA.

A floating-point operation — the unit in which training compute is counted.

A single floating-point calculation; total FLOPs is the standard measure of how much computation a training run consumed. The currency of scaling laws and of the frontier's eye-watering budgets.

A large, general model trained once and adapted to many downstream tasks.

A model trained at scale on broad data so it can be adapted — by fine-tuning or simply prompting — to a wide range of tasks rather than one. An LLM is the best-known kind; image and multimodal foundation models exist too.

The most capable models in existence at any moment — and the most expensive to build.

The leading edge of capability — the handful of models, mostly closed, that top the benchmarks and cost the most compute to train. The subject of most safety, alignment and regulatory attention.

Letting a model invoke external tools and APIs by emitting structured requests.

Also "tool use": the capability by which a model outputs a structured call to an external function or API — search, code execution, a database query — and incorporates the result. The mechanism that turns a chatbot into an agent.

AI that produces new content — text, images, audio, code — rather than just classifying it.

Systems that create novel output rather than label existing input. Text generators are LLMs; image and video generators are usually diffusion models. The defining behaviour, and its defining failure mode, is hallucination.

A curated set of inputs with known-good expectations — the regression suite a model is graded against on every change.

The headline instrument of evaluation: a hand-picked set of representative and adversarial inputs, each with an expected outcome, that every prompt, model or retrieval change is scored against before it ships. Coverage of the scenarios that actually matter is the discipline; every production incident should end its life as a new case in the set. Pairs with LLM-as-a-judge for cheap automated grading and with sampled live quality for what the dataset misses.

A graduate-level science benchmark deliberately resistant to web lookup.

Graduate-Level Google-Proof Q&A: expert-written science questions hard enough that even skilled non-specialists with web access struggle. One of the benchmarks that replaced the saturated MMLU at the frontier.

The parallel processor that does the heavy maths of training and inference.

The Graphics Processing Unit — repurposed from rendering — whose massively parallel arithmetic underpins deep learning. Nvidia's data-centre GPUs dominate the market and define the cost of building frontier models.

The optimisation method that nudges weights to reduce error, step by step.

The workhorse optimisation algorithm: compute how a small change to each weight would change the loss, then step in the direction that lowers it. Repeated billions of times, it is how a model learns. Backpropagation supplies the gradients.

Tying a model's output to verifiable, supplied evidence.

Anchoring a model's response in specific, provided sources — documents, search results, structured data — so claims can be traced and checked. The mechanism, usually via RAG, that most reduces hallucination.

Rules and filters constraining what a model will say or do.

The policies, filters and refusals that bound a model's behaviour — set partly by fine-tuning and partly by the system prompt. Probed by red teaming and attacked by jailbreaks.

When a model states something fluent, confident and false.

The generation of plausible but incorrect or fabricated content — a model's signature failure mode, rooted in its training to be fluent rather than truthful. Mitigated, never fully cured, by grounding, RAG and careful evaluation.

The software scaffolding around a model that turns it into a working agent.

The program that wraps a model and makes it useful: it runs the agent loop, exposes tools via function calling, assembles the prompt and context, parses outputs, handles retries and errors, and enforces limits. Two labs using the same model can get very different results from a better or worse harness — increasingly, the harness is where much of the engineering value (and the evaluation effort) now lives.

Keeping a person accountable for reviewing or approving an AI system's actions.

A design in which a human reviews, approves or can override what an agent does, especially where mistakes are costly. It is the practical answer to hallucination and the foundation of trust in regulated and industrial settings — autonomy is earned workflow by workflow, behind guardrails.

Running a trained model to produce an answer — the cost you pay per use.

Using a finished model to generate output, as opposed to training it. It is where most real-world cost and latency live, which is why quantization, the KV cache and specialised inference chips matter so much commercially.

Silicon optimised for serving models cheaply and fast, not training them.

Hardware — from Nvidia parts to specialised startups' designs — tuned for running finished models at low latency and cost rather than training them. As usage scales, inference silicon is where much of the commercial battle is shifting.

The science of understanding what is actually happening inside a model.

Research aimed at opening the black box — explaining which internal features and circuits drive a model's behaviour. Seen as essential to trustworthy alignment, since you cannot fully steer what you cannot inspect.

A prompt that tricks a model into bypassing its safety guardrails.

An input crafted to coax a model past its guardrails into producing restricted content. Distinct from prompt injection, which hijacks an application's instructions. A perennial target of red teaming.

The date after which a model's training data ends — and its built-in knowledge stops.

The point in time at which a model's pretraining data was frozen; it has no inherent knowledge of later events. Bridged at runtime by RAG, web tools or agents.

Stored attention state that lets a model avoid recomputing the whole context each token.

The cache of key/value attention tensors a model keeps while generating, so each new token reuses prior work instead of recomputing the entire context window. It is the main memory cost of long-context inference.

A model trained on vast text to predict the next token, and thereby to read and write language.

A neural network — almost always a transformer — trained on enormous text corpora to predict the next token. From that one objective emerges fluent writing, translation, code and a surprising amount of reasoning. Size is measured in parameters; the leading examples are frontier models.

Wiring an AI capability into the real systems and workflows where work happens.

The unglamorous engineering that connects a model to the system of record, the user's screen and the surrounding process — usually the difference between a demo and a deployment. Under-scoping it is the leading cause of pilot purgatory.

How long a model takes to respond; throughput is how many requests it serves at once.

The delay between request and response — particularly time-to-first-token — which, alongside throughput (volume served), defines the user experience and the economics of inference. The KV cache is a primary lever on both.

Using a language model to grade another model's outputs — cheap, scalable, and dangerous if uncalibrated.

The practice of asking an LLM to score another model's outputs against a rubric — faster and cheaper than a human panel, and essential at the scale modern evaluation demands. The catch is calibration: an LLM judge that has not been checked against human labels gives confident, wrong grades. The honest pattern is to sample-audit judge scores against humans and watch judge-human agreement as a first-class signal in observability.

The practices and tooling for running language-model systems reliably in production.

The operational discipline — versioning, evaluation, monitoring, prompt and retrieval management, cost control — that keeps an AI system dependable after launch. The successor to MLOps for generative systems, and a major line in any honest total cost of ownership.

Low-Rank Adaptation — fine-tuning a model by training a tiny set of extra weights.

Low-Rank Adaptation, the leading parameter-efficient fine-tuning (PEFT) method: instead of updating all the weights, it trains a small add-on, slashing the cost of specialising a large model. Often paired with quantization.

The number a model tries to minimise — its measure of being wrong.

A formula that scores how far a model's output is from the desired one. Training is the search for weights that minimise it, via gradient descent. Watching it fall — and watching for overfitting — is how training is monitored.

Software that learns patterns from data rather than following hand-written rules.

A discipline in which a program improves at a task by learning statistical patterns from examples, rather than executing rules a programmer wrote by hand. Every modern large language model is a machine-learning system. The dominant modern flavour is deep learning.

A design where only a fraction of the model's parameters fire for any given token.

An architecture that splits a model into many "expert" sub-networks and routes each token to only a few, so a model can hold enormous parameter counts while keeping the per-token compute — and therefore cost — low. Most efficient frontier models now use it.

A broad knowledge benchmark, now largely saturated at the frontier.

Massive Multitask Language Understanding: a multiple-choice exam across 57 subjects, long the default headline benchmark. Frontier models now score so highly that it is considered saturated and of limited discriminating value.

Trying a cheap model first and escalating to a stronger one only when needed.

A routing pattern that sends every request to a small, inexpensive model first and only escalates to a more capable, costly one when confidence is low or the task demands it. A close cousin of the model router, it can cut cost per token dramatically while preserving quality on the hard minority of requests — provided the escalation signal is well calibrated against hallucination.

An open standard (MCP) for connecting models to tools and data sources.

An open protocol, introduced by Anthropic and now widely adopted, that standardises how models connect to external tools, data and services — a common socket so every agent need not be wired by hand. Built atop function calling.

The system of record for which model, prompt and retrieval version ran in which environment, approved by whom.

A registry that tracks every model and configuration artefact through its lifecycle — development, evaluation, canary, production, rollback — along with the approvals and eval results that gated each transition. It is the audit trail and the operational lever in one object, and the spine of disciplined prompt management and LLMOps.

A layer that sends each request to the most appropriate model for it.

A dispatcher that inspects each incoming request and directs it to the best-fit model — a small, cheap model for easy queries, a reasoning model for hard ones — to optimise cost, latency and quality together. Routing can be rule-based or learned (a classifier or semantic match), and it is the practical engine of a model-agnostic architecture, closely related to the cascade.

A system designed so the underlying model can be swapped without rebuilding.

An engineering posture that treats the model as a replaceable component behind a stable interface, so a cheaper or better one can be dropped in next month. With capability converging and cost per token falling, it is the defining discipline of a durable enterprise AI strategy — and the antidote to vendor lock-in.

A model that handles more than one type of data — e.g. text plus images, audio or video.

Describing a model that accepts or produces multiple data types — text, image, audio, video — within one system, mapping them into a shared space of embeddings. Frontier assistants are now natively multimodal rather than text-only.

A network of simple numerical units, loosely inspired by the brain, that learns by adjusting weights.

A mathematical structure of interconnected units ("neurons"), each applying a simple operation, arranged in layers. Learning happens by tuning the connection strengths, or weights, via backpropagation and gradient descent. The transformer is the neural-network design that powers modern language models.

Seeing what an AI system actually does in production — traces, signals and alerts on the metrics that matter.

The operational capability of reading a live AI system: end-to-end traces of every request (prompt version, retrieved documents, model, tokens, latency, cost), sampled scoring of live quality, and alerts on drift, error rate and cost. Observability is the heart of LLMOps — without it, a regression is unanalysable and the dashboard, not the system, is what fails. Its data feeds the golden dataset after every incident.

Models whose trained weights are published for anyone to run and adapt.

Models — Llama, DeepSeek, GLM and others — whose weights are released publicly, so anyone can run, fine-tune or quantize them. Distinct from fully open-source (which would include training data), and the competitive counterweight to closed models.

Coordinating multiple model calls, tools and agents into a reliable workflow.

The layer that sequences and supervises model calls, tool use and — increasingly — multiple agents working together, handling memory, retries and control flow. Where much applied-AI engineering effort now sits.

The standard manufacturing metric of availability × performance × quality.

The benchmark measure of how productively a manufacturing asset runs, combining uptime, speed and yield. It is the kind of pre-existing, owned number that makes manufacturing an ideal first home for AI — moving OEE a point is a business case everyone already understands.

When a model memorises its training data instead of learning to generalise.

The failure in which a model fits its training data so closely that it performs poorly on anything new — low loss in training, high error in the wild. The reason models are held to unseen evaluation sets.

A single learned number inside a model; counts run into the hundreds of billions.

One of the adjustable numbers a model learns during training — collectively the model's weights. Parameter count (e.g. "70B") is a rough proxy for capacity, though mixture-of-experts designs and scaling laws complicate the simple bigger-is-better reading.

A measure of how well a model predicts text; lower is better.

An intrinsic metric of language-model quality: roughly, how "surprised" the model is by held-out text. Lower perplexity means better prediction. Useful in training, but a weak proxy for real-world usefulness, which is why the field leans on benchmarks.

The graveyard where promising AI pilots stall short of production.

The common fate of AI programmes: a parade of successful proofs of concept that never ship, because the hard work of last-mile integration, governance and change management was never scoped. Escaping it means picking fewer use cases and funding them all the way to a number on the P&L.

Using AI to flag equipment failure before it happens, rather than on a fixed schedule.

Reading sensor, ERP and maintenance-log signals to predict and pre-empt breakdowns — one of the first places agents land on a factory floor. The value is concrete: downtime avoided, a number a plant manager already owns and can put in a business case.

The initial, expensive phase where a model learns from vast unlabelled data.

The first and costliest phase of building a foundation model: predicting the next token across a vast corpus, learning language and world structure with no human labels — a form of self-supervised learning. What follows is fine-tuning.

The instruction or input you give a model to get a response.

The text (or image, audio, etc.) you give a model to elicit a response. Crafting it well is prompt engineering; the hidden instruction that frames a whole session is the system prompt.

The craft of phrasing inputs to get reliable, high-quality outputs.

The practical art of structuring prompts — instructions, examples, formatting — to steer a model toward better, more reliable answers. Techniques include few-shot examples and chain-of-thought prompting.

Hostile instructions hidden in data that hijack an AI application's behaviour.

A security attack in which malicious instructions, smuggled into content the model reads — a web page, a document, a tool result — override the developer's system prompt. The signature vulnerability of agents and RAG systems.

Treating prompts and retrieval configs as versioned, reviewable artefacts rather than hard-coded strings.

The practice of storing prompts, retrieval sources and model choices in a registry, versioned and reviewable, so any production behaviour can be traced to an exact configuration and a bad change can be rolled back in seconds. It is half of LLMOps; the other half is evaluation and observability. Closely tied to the model registry that records what shipped and who approved it.

A small, time-boxed build to test whether an AI use case is viable.

A deliberately narrow experiment to validate feasibility and value before committing to production. A good POC has a defined success metric and an exit; a bad one becomes pilot purgatory. The point is to learn quickly and earn the right to invest in time-to-value, not to impress with a demo.

Storing a model's weights at lower numerical precision to shrink and speed it.

Reducing the numerical precision of a model's weights — say from 16-bit to 4-bit — to cut memory and accelerate inference, usually with modest quality loss. Key to running capable open-weights models on modest hardware.

The instrument that operationalises a readiness assessment — a role-tagged questionnaire across eight dimensions.

The questionnaire that turns an AI readiness assessment into numbers: respondents rate statements across eight dimensions on a 1–5 scale, tagged by role so the divergence between leadership and the front line can be reported as a finding. Dimension scores are averaged; the overall score maps to an AI maturity model band, and the ethics dimension is the bridge into formal governance and compliance work.

A model trained to think longer at inference time, spending compute to reason.

A class of model trained — typically with reinforcement learning — to deliberate at length before answering, trading extra inference compute ("test-time compute") for accuracy on maths, code and logic. The behaviour generalises chain of thought.

Deliberately attacking a model to find its failures before release.

The practice of adversarially probing a model — for harmful outputs, jailbreaks, prompt injection — to surface weaknesses before deployment. A core part of alignment and safety evaluation.

Learning by trial and error against a reward signal.

Training in which an agent takes actions and learns from a reward signal rather than labelled answers. In language models it powers RLHF, RLAIF and the training of reasoning models.

The practices that keep AI use fair, transparent, accountable and lawful as it scales.

The umbrella for fairness, transparency, explainability, privacy and accountability in how AI is built and used. It is the human-readable face of AI governance and the seam through which a readiness survey flows into formal compliance and audit — where principles become controls a regulator can inspect.

Fetching relevant documents at query time and feeding them to the model to ground its answer.

A pattern that, at query time, retrieves relevant text from a knowledge store — usually via embeddings in a vector database — and places it in the model's context window, so answers are grounded in real sources rather than memory. The standard remedy for hallucination and a stale knowledge cutoff.

Reinforcement Learning from AI Feedback — using a model, not humans, to score outputs.

Reinforcement Learning from AI Feedback: an AI judge supplies the preference signal that humans give in RLHF, cutting cost and improving consistency. Closely tied to Constitutional AI.

Reinforcement Learning from Human Feedback — tuning a model to human preferences.

Reinforcement Learning from Human Feedback: humans rank model outputs, a reward model learns those preferences, and the model is fine-tuned to satisfy them. The technique that turned raw LLMs into usable assistants. Its scalable cousin is RLAIF.

How a model chooses each next token from its predicted probabilities.

The procedure for selecting the next token from the model's probability distribution. Knobs such as temperature and top-p trade off coherence against diversity. Deterministic "greedy" decoding always takes the most likely token.

Empirical curves showing performance improves predictably with more data, compute and parameters.

The observed regularities by which a model's quality improves smoothly as data, parameters and compute grow. They underwrite the industry's enormous capital bets and the notion of compute-optimal training.

Creating the labels from the data itself — e.g. predict the next word.

A training scheme that manufactures its own supervision from raw data — for language, by hiding the next token and asking the model to predict it. It is the quiet breakthrough that let pretraining scale to the entire web.

Unsanctioned use of AI tools by staff, outside any governance.

Employees pasting sensitive data into consumer AI tools without approval — a data-leakage and prompt-injection risk that proliferates wherever official tools are slow or absent. The cure is rarely prohibition; it is providing sanctioned tools under proper governance.

An alternative to attention (e.g. Mamba) that scales linearly with sequence length.

A family of architectures — Mamba being the best known — that process sequences with a recurrent, linear-time mechanism instead of quadratic attention, promising cheaper handling of very long contexts. Still a challenger to, not a replacement for, the transformer.

Learning from labelled examples — input paired with the correct answer.

Training on data where each input carries a correct label, so the model learns to map one to the other. Contrast with unsupervised and self-supervised learning, which need no hand labels.

A benchmark of real software bugs a model must resolve with working code.

A demanding evaluation in which a model must fix genuine issues from open-source repositories, with success judged by passing tests. The leading measure of practical coding and agentic ability.

Training data generated by models rather than collected from the world.

Data produced by AI systems and used to train or fine-tune other models — increasingly important as high-quality human text grows scarce. Central to techniques like distillation and RLAIF, and a subject of debate over quality and feedback loops.

The authoritative business system — ERP, CRM, MES — that holds the data of truth.

The application a business treats as the canonical source for a domain of data: the ERP for operations, the CRM for customers, the MES on a plant floor. Most enterprise AI value comes from grounding answers in it — via RAG and grounding — and writing actions back to it, not from the model's own memory.

A hidden, persistent instruction that sets a model's role and rules for a session.

A standing instruction, set by the developer rather than the end user, that defines an assistant's persona, constraints and guardrails for an entire conversation. A frequent target of prompt injection.

A dial controlling randomness: low is focused and repeatable, high is creative.

A sampling parameter that scales how adventurously a model picks the next token. Near zero it is near-deterministic and precise; higher values add variety and risk, including more hallucination.

How long before an AI initiative produces measurable business benefit.

The elapsed time from starting work to delivering a real, quantified result. Short time-to-value protects momentum and budget; it is why mature programmes prefer a narrow workflow shipped this quarter over a platform that pays off in two years. A core input to any business case.

The atomic unit of text a model reads and writes — roughly a word-piece.

The chunk of text a model actually processes: often a short word or fragment of one, produced by tokenization. Models predict the next token, are billed per token (see cost per token), and can only hold so many in their context window.

Splitting raw text into the tokens a model can process.

The pre-processing step that breaks text into tokens using a fixed vocabulary, then maps each to an embedding. It quietly shapes cost, context length and how well a model handles rare words, code and non-English scripts.

The full lifetime cost of an AI system — not just the model's per-token bill.

The complete cost of running an AI capability: model inference (see cost per token), but also data pipelines, retrieval infrastructure, LLMOps, human review, integration and change management. TCO is what turns an impressive proof of concept into an honest business case; under-counting it is why so many systems fail at the second invoice.

Google's custom chip purpose-built for neural-network maths.

Tensor Processing Unit: Google's application-specific accelerator designed expressly for deep learning, an in-house alternative to the GPU and part of the broader race in inference chips.

Reusing knowledge from one task to accelerate learning on another.

The principle that a model trained on one broad task can be adapted to many others — the reason a single foundation model can be fine-tuned for countless applications instead of trained from scratch each time.

The 2017 neural-network architecture behind virtually every modern LLM.

The architecture, introduced in the 2017 paper "Attention Is All You Need", that replaced recurrence with attention and made large-scale language modelling practical. Almost every LLM and many multimodal and diffusion systems are transformers at heart.

Finding structure in data that carries no labels.

Training that discovers patterns — clusters, structure, representations — in unlabelled data. Its modern descendant, self-supervised learning, is what makes pretraining on raw text possible.

Ranking candidate AI applications by business value against feasibility — not by novelty.

The exercise of scoring each candidate application on the value it would create versus the difficulty of delivering it, then sequencing accordingly. It is the single most important step in an enterprise AI strategy: it kills vanity projects early and points scarce effort at the workflows where a clear business case and an accountable owner already exist.

A store optimised for finding the embeddings nearest to a query.

A database built to index and search embeddings by similarity, returning the items closest in meaning to a query. The retrieval engine inside most RAG systems.

Dependence on one provider that is costly to switch away from.

The risk that an architecture becomes so entangled with a single model or platform that changing it is prohibitively expensive — dangerous in a market where the best, cheapest option changes quarterly. The standard mitigation is a model-agnostic design and a deliberate build-vs-buy line.

The full set of learned parameters that define a trained model.

The complete collection of a model's learned parameters — in effect, the model itself as a file. Whether a lab publishes them is the line between an open-weights and a closed model.