AI GLOSSARY

Software that does tasks normally needing human judgment — recognizing, classifying, predicting, generating, deciding. John McCarthy coined the name in 1955, in the proposal for the Dartmouth conference held the next summer. He wrote it with Marvin Minsky, Nathaniel Rochester and Claude Shannon. The name was chosen to christen a new field, not to describe a technique, and it has never had a technical meaning since. That is why it stretches from a 1970s rules engine to a frontier language model, and means almost nothing on its own.

Everything supplied to a model for a single call — the system prompt, the user's message, retrieved documents, tool results and the conversation so far. It is the model's entire working memory: nothing outside it exists for that request, and nothing inside it persists to the next one unless you send it again.

The maximum amount of text a model can consider at once — the prompt, any retrieved documents, the conversation so far and the answer it is producing, all counted together. Exceed it and the earliest content is dropped or the request fails outright.

Machine learning that uses neural networks with many layers. The layers work out for themselves which features of the data matter, rather than a person choosing them first. It is what powers image recognition, speech-to-text and language models. The trade is raw power on messy inputs, paid for with more data and much less ability to explain the answer.

A large, general-purpose model trained once at great expense on broad data, then adapted to many downstream tasks by prompting, fine-tuning or tool use. The economic point is that the expensive part is shared: organizations build on a foundation model instead of training one, the way they build on a cloud platform instead of a data center.

AI that produces new content — text, code, images, audio, video, structured data — rather than only scoring or classifying existing content. Generative systems predict plausible continuations of their input, which is why they are fluent, fast and capable of being confidently wrong in the same breath.

Running a trained model to get an answer, as opposed to training it in the first place. Training is a large one-off cost; inference is the recurring one, paid on every request for as long as the feature is live.

The date after which a model's training data stops. Anything that happened later — a price change, a regulation, a reorganisation, a competitor launch — is simply absent, and the model has no way to know it is missing. Models are also unreliable narrators of their own cutoff, so asking one is not a check.

A model trained on huge amounts of text to predict what comes next. That turns out to be enough to summarize, translate, reason over documents, write code and hold a conversation. An LLM has no database and no memory of your company. Everything it seems to know was either baked into its weights during training or handed to it in the prompt.

A family of techniques in which a system learns patterns from data rather than following rules a person wrote. You supply examples and a target; the training process fits a model that maps one to the other, and the model is then used on inputs it has never seen. Forecasting, fraud scoring, churn prediction and recommendation are all classical ML, and most of them long predate generative AI.

A model that handles more than one kind of input at once — text with images, audio, video or files. It does this in a single context, rather than chaining separate tools together. So it can read a scanned contract, a chart and the email about them as one thing, then answer a question across all three.

A model made of layers of simple units, each passing a weighted sum of its inputs through the next layer, where the weights are learned from data rather than written by hand. Nothing about it is neurological beyond the metaphor — it is arithmetic at scale, and the "learning" is a search for weights that make the output match the training examples.

The unit a language model actually reads and writes — roughly a word fragment. English averages about four characters per token, so 750 words is near 1,000 tokens. Context limits, latency and price are all denominated in tokens, not words or pages.

The mechanism that lets a model weigh every token against every other when deciding what each one means, so "it" can be connected to the right noun forty words back. It is the core idea of the transformer, and its cost grows with the square of the sequence length, which is why long contexts are expensive rather than merely large.

Training a smaller model to reproduce the behavior of a larger one on a target task, keeping most of the quality at a fraction of the cost and latency. Distillation is how a capability proven on an expensive model becomes economic to run at scale.

A dial that says how hard a reasoning model should work on this one request. Low answers fast and cheap. High thinks longer, tries more approaches and checks itself before replying. It is the setting that turns test-time compute from a property of the model into a choice you make per call. Every major provider exposes one now, under slightly different names and scales.

A list of numbers that stands in for a piece of content — a sentence, a document, an image — placed so that things with similar meaning sit close together. This is what lets a system search by meaning instead of by keyword. It sits underneath retrieval, clustering, de-duplication and recommendation.

Continuing to train an existing model on your own examples so it adopts a format, a house style or a specialized task. Fine-tuning changes behavior reliably; it is a poor way to teach facts, because the knowledge is frozen at training time and cannot be updated, cited or removed on request.

The saved working state from tokens already processed, kept so the model does not redo the whole sequence for each new token. It is what makes generation fast enough to be usable. It also eats memory in proportion to how long the context is and how many people are using it at once.

An architecture that splits a model into many specialized sub-networks and activates only a few per token, so a very large model can be served at the cost of a much smaller one. It is a primary reason capability has kept climbing while price per token has kept falling.

A model whose trained weights are published for download. You can run it on your own infrastructure, inspect it, and adapt it without an API call leaving your network. Open weights are not the same as open source: the training data and code usually stay private, and licences run from genuinely permissive to sharply restricted.

The learned weights inside a model, counted in billions — the "7B" or "70B" in a model's name. More parameters generally means more capability and always means more memory and more cost to run: at sixteen-bit precision a 70B model needs roughly 140GB just to hold, before any serving overhead. Parameter count says nothing about training data quality, so a smaller model trained well routinely beats a larger one trained carelessly.

Storing a model's parameters at lower numerical precision so it needs less memory and runs faster, with a small and measurable loss of quality. It is the standard technique for fitting a capable model onto modest hardware or a device.

A model trained to spend extra computation working a problem through before it answers, thinking in a scratchpad the user may never see. These models are much stronger on multi-step maths, code and analysis. They are also much slower and cost more per answer.

A training stage in which human raters compare model outputs and their preferences are used to steer the model toward helpful, honest and harmless responses. It is the step that turns a raw text predictor into something that follows instructions and declines the requests it should decline.

How the next token is picked from the probabilities the model produces. Temperature flattens or sharpens the distribution; top-p keeps only the most likely options that together reach a probability threshold; top-k keeps a fixed number. Greedy decoding always takes the most likely token and is the closest thing to deterministic output.

A compact model — typically a few billion parameters — designed to run cheaply, quickly, and often on your own infrastructure or a device. Small models trail frontier models on open-ended reasoning but can match them on narrow, well-specified tasks such as classification, extraction and routing.

A speed technique in which a small fast model drafts several tokens ahead and the large model verifies them in one pass, keeping what it agrees with. Output is identical to what the large model would have produced alone; only the wall-clock time changes.

A sampling control over how much randomness enters generation. Low values make the model favor its most likely next token and produce repetitive, predictable text; higher values widen the field. Note that temperature 0 is not the same as deterministic — batching and floating-point ordering mean identical inputs can still diverge.

Spending more computation at the moment of answering rather than during training — letting a model reason for longer, sample several attempts, or check its own work before replying. It is the axis reasoning models scale on, and it converts money into accuracy per request instead of per run.

The component that cuts text into the tokens a model actually consumes, using a fixed vocabulary learned before training. Common English words are usually one token; rare words, names, code and most non-English text fragment into several.

The neural network architecture behind essentially every modern language model, introduced by Google researchers in 2017. Its defining move is attention: instead of reading a sequence strictly in order, the model weighs how much each part of the input should inform each other part. That is what allows a model to connect a pronoun to a name forty sentences earlier.

A model that takes in what a camera sees and an instruction in plain language, and puts out the actual movements — where to send a joint, when to close a gripper. It is the same architecture family as a large language model, trained to produce motion instead of text. Google's RT-2 in 2023 is the one usually cited first.

The algorithm that works out how much each weight in the network contributed to the error, by propagating it backwards from the output layer to the input. It is what makes gradient descent tractable on a network with billions of weights rather than merely theoretical.

The raw output of pre-training, before any instruction tuning or preference work. It continues text rather than answering questions, has no notion of a conversation, and will happily produce anything its training data contained. Every assistant you have used is a base model with post-training on top.

How many examples the model sees before each weight update. Larger batches give a steadier estimate of the right direction and need proportionally more memory, which is usually what caps it in practice.

The tendency of a model to lose previously learned capability when trained on something new. Fine-tune hard on legal documents and general reasoning degrades; the model has not been extended so much as bent.

Given a fixed compute budget, the best split between model size and training data. Hoffmann et al. showed in 2022 that the models of the preceding era were substantially too large for the data they had seen, and that a smaller model trained on more tokens beats a larger one trained on fewer.

Training a model to critique and revise its own outputs against a written set of principles, so that much of the feedback comes from the model rather than from human labelers. The principles are explicit and published, which makes the target of the training inspectable in a way a pile of preference labels is not.

A way of tuning a model on human preferences that skips the reward model RLHF needs, optimizing directly on pairs of responses where one was judged better. Simpler to run and far cheaper, which is why most teams outside the frontier labs use it rather than full RLHF.

One complete pass over the training set. Small fine-tuning jobs run for a handful; frontier pre-training runs typically see most data once or twice, because at that scale fresh data beats repetition.

Training one shared model across many places without moving the data. Each site trains on what it holds and sends back only the changes to the model; a coordinator averages them. The raw records never leave. Google published the method in 2016 and used it on phone keyboards.

The optimization method behind essentially all model training: work out which direction each weight should move to reduce the loss, take a small step that way, repeat several million times. The "gradient" is the slope of the loss with respect to every weight at once.

Training a base model on examples of instructions paired with good responses, so it answers questions instead of continuing text. It is the first step of post-training and the one that turns a text predictor into something recognisably an assistant.

The size of the step taken at each update. Too large and training overshoots and destabilises; too small and it crawls or settles somewhere mediocre. It is usually scheduled rather than fixed — larger early, decayed as the run proceeds.

Low-Rank Adaptation — fine-tuning that freezes the original weights and trains a small set of new ones alongside them, typically well under one percent of the model's size. The result is a lightweight adapter file rather than a whole new model, and several can be swapped in and out against one shared base. The broader family is parameter-efficient fine-tuning.

The number training is trying to make smaller — a measure of how wrong the model's output was on each example. Every weight update is a step toward reducing it, so the loss function is the operational definition of "better" for the entire run.

The degradation that sets in when models are trained on output from earlier models, generation after generation. Rare cases at the tails of the distribution disappear first, so the result grows blander and more confident while looking superficially fine.

When a model learns the training examples rather than the pattern behind them — excellent on data it has seen, poor on anything new. The mirror failure is underfitting, where it has not learned enough to be useful either. A held-out test set is what tells the two apart.

Everything done to a base model to make it useful and safe. First instruction tuning, then preference tuning through RLHF or DPO, plus safety work and often distillation. Set against pre-training it costs almost nothing. It is also responsible for nearly everything a user experiences as the model's character.

The first and by far the most expensive stage: one very long run over a vast corpus of text, in which the model learns to predict what comes next and, in doing so, absorbs grammar, facts, reasoning patterns and a great deal of the internet's opinions. It produces a base model that completes text but does not yet follow instructions or refuse anything.

Learning by trial against a reward signal rather than from labeled examples: the system acts, gets scored, and adjusts toward whatever scores well. It is how game-playing systems were trained, and through RLHF and its successors, how language models are shaped after pre-training.

A second model trained to predict which of two responses a human would prefer, used as a stand-in for human judgment so the main model can be optimized against it at scale. It is the piece that makes RLHF possible and the piece most likely to be gamed.

Learning from unlabelled data by hiding part of it and predicting the hidden part — for language models, predicting the next token. The labels come free from the data's own structure, which is what made training on internet-scale text possible at all.

Training a robot in simulation, then moving what it learned onto the real machine. Simulation is cheap and fast, so a policy can practise years of simulated time in a weekend. The catch is that no simulator is right. Friction, light, wear and the odd shove are all a little off, and a policy tuned to the simulator can fall apart outside it.

Continuing training on a curated set of input–output pairs that demonstrate the behavior you want. "Supervised" means every example carries the right answer, written by someone. It is the workhorse of post-training and the form of fine-tuning most vendors actually sell.

Learning from examples that carry the right answer — emails labeled spam or not, invoices labeled approved or rejected. The model learns the mapping from input to label, and the labels have to come from somewhere, usually people.

The corpus a model learns from. For pre-training it is web text, books, code and licensed collections at a scale nobody reads end to end; for fine-tuning it is whatever you supply. Composition determines capability, bias and much of the legal exposure, and frontier labs disclose it in varying and generally decreasing detail.

Taking a model trained on one task and adapting it to another, rather than starting from nothing. The general capability built during pre-training carries over, and only the last stretch is task-specific — which is the premise the entire foundation-model industry rests on.

Finding structure in data with no labels — clustering customers, spotting anomalies, reducing dimensions. Nobody says what the right answer is, so the model reports patterns and a person decides whether they mean anything.

A system or process designed around what AI can do, rather than an existing workflow with AI added to one step. AI-native design assumes the model in the architecture from the start — which typically means fewer handoffs and different roles, not the same process running faster.

Prompting a model to work through intermediate steps before committing to an answer, which improves accuracy on problems that need more than recall. The stated reasoning is a useful artifact but not a guaranteed account of how the answer was produced.

Deciding what actually occupies the context window on each call — which retrieved passages, how much conversation history, which tool results, what memory, in what order — as distinct from how the instruction is worded. As systems moved from single prompts to agents and retrieval, this became the larger half of the job.

Running the model where the data is made, instead of sending it to a data centre. On the camera. On the machine. On the vehicle, or the store's own server. On-device AI is the tightest version, where it runs on the end device itself, like a phone. This is why models get shrunk: quantization, distillation and small models all exist to fit something into a small place.

Including a handful of worked examples in the prompt so the model infers the pattern you want instead of being told it in the abstract. Showing three correctly formatted answers is usually more effective than three paragraphs describing the format.

Designing the shape of a system that several agents work inside: which units of work exist, what may pass between them, what they share, and who decides where the work goes next. The name arrived in mid-2026 and is not settled, and it gets used for two different things. Say which you mean. A task graph is how work moves through one run. A knowledge graph is what the system knows about the business, and it outlives every run.

Checks wrapped around a model that limit what goes in and what comes out. They cover input filters, output checks, required formats and refusal rules. They also cover caps on rate and spend, and when to hand a case to a person. Guardrails are plain, predictable code around an unpredictable part.

Everything around the model that makes one agent run: the tools it may call, the files it can see, the permissions it holds, the sandbox it works in, and what gets assembled into its context each turn. The model is bought. The harness is built. Two teams on the same model get very different results because of it.

A design in which a person reviews, approves or corrects the system's output before it takes effect — usually on the consequential subset rather than everything. Well built, the review queue is also a training signal: every correction is a labeled example of what good looks like.

How long the system takes to answer. Two numbers matter and they behave differently: time to first token, which is when the response starts appearing, and total completion time. With streaming, the first is what a user experiences as speed, even when the second is unchanged.

Designing the system that runs an agent, rather than prompting the agent yourself. You set the goal, the tools it may call, what it keeps between passes, how its output gets checked, and what makes it stop. Geoffrey Huntley showed the pattern in July 2025 with a coding agent in an endless shell loop. Addy Osmani named the practice in June 2026.

A plain-text way of marking up writing — asterisks for bold, `#` for a heading, hyphens for a list. It predates AI by two decades. Models default to it because so much of what they learned from was written in it, which is why answers arrive full of `##` and `**` when nothing renders them. It is now also the format agent instructions are written in.

An open standard, introduced by Anthropic in late 2024 and since adopted across the industry, for connecting AI applications to external tools and data sources through a common interface. It replaces bespoke per-integration glue with one protocol that any compliant client and server can speak.

Classifying each request and sending it to the cheapest model that can handle it, rather than sending everything to the best one. A small model takes the routine majority; a frontier or reasoning model takes the hard remainder.

The layer that decides what runs in what order: which model handles a request, which tools it may call, how retries and failures are handled, what gets logged, and when a human is brought in. It is ordinary software engineering, and it is most of the system.

Designing the instructions, examples and structure you give a model. The goal is output that is right every time, not right now and then. In production it looks less like clever phrasing and more like writing a spec: the task, the format, the edge cases, and what to do when the input is unusable.

A folder of written instructions an agent loads when the job calls for it — conventions, steps, the thing you do not do any more because of that one incident. Usually a `SKILL.md` file plus any scripts or reference material it needs. The agent reads it on the runs where it is relevant and ignores it otherwise. Anthropic defined the format and other tools have adopted it.

Constraining a model to return data in a fixed shape — JSON matching a schema, a defined set of labels, a specific field list — rather than prose a downstream system then has to parse. Most providers now enforce this during generation rather than hoping the instruction is followed.

The standing instruction that governs a model's behavior across every request in an application — its role, its boundaries, its tone, its output format. Users supply the question; the system prompt supplies the job description.

Giving a model the ability to call software — a search index, a database query, a pricing API, a calculator — and use the result in its answer. The model decides which tool fits and with what arguments; your code decides what tools exist and what they are permitted to do.

Rebuilding a process once AI is in it. Some steps automate. Some become human-AI loops. Some vanish, because they only existed to work around a constraint that is now gone. This is not augmentation, where every step stays and gets help, and not replacement, where the whole process is handed over.

How a system carries information across steps and sessions, since the model itself remembers nothing between calls. Short-term memory is the running context; long-term memory is an external store the agent writes to and retrieves from deliberately.

The broad category of AI systems that act rather than only answer. In practice the label spans everything from a model calling two tools in sequence to a long-running process that manages a workflow for days, so it says far more about ambition than about architecture.

A system that pursues a goal over multiple steps, choosing its own actions along the way — calling tools, reading results, revising its approach — rather than producing one answer to one prompt. The distinguishing feature is not intelligence but discretion: nobody specified the sequence in advance.

AI that assists a person inside the work they are already doing — suggesting, drafting, completing — where the person invokes it and decides whether to accept what comes back. The distinguishing feature is that a human is in the loop by construction, not by policy.

An agent's basic working cycle: take a goal, plan, call a tool, look at what came back, decide whether the job is done, and go again. A single model call answers a question. A loop keeps going until a stopping rule fires. Almost everything sold as an AI agent is a loop with tools attached.

An architecture in which several specialized agents work on parts of a problem and coordinate — one researches, one drafts, one checks — usually under a coordinating agent. It buys parallelism and separation of concerns at the cost of more failure modes and much harder debugging.

Rule-based automation that replays a fixed sequence of user-interface or API actions — the generation of automation that preceded AI agents. RPA is deterministic and auditable, and it breaks the moment a screen, a form or an exception falls outside its script.

Retrieval where the model decides what to look for. It can rewrite a vague question into a better search, look again, notice that what came back does not answer the question, and try once more. Ordinary RAG runs one search and works with whatever it gets.

Splitting documents into passages small enough to retrieve precisely and large enough to still make sense on their own. Chunk on the document's actual structure — sections, clauses, rows — rather than every N characters, or you will routinely retrieve half a sentence and half an answer.

Degrading answer quality as the context grows, even well inside the window. Liu and colleagues documented the shape of it in 2023: models attend most reliably to material at the beginning and the end of a long context and can miss what sits in the middle, so adding more passages can make a system worse.

Whether the data an AI use case depends on actually exists, is accessible, is current, and is trustworthy enough to act on. Readiness is assessed per use case, not per organization: the same company can be fully ready for one workflow and nowhere near it for the one next to it.

A retrieval method that builds a knowledge graph before it answers anything. A model reads your documents and pulls out the people, places and things in them, plus how they connect. It groups the closely linked ones and writes a summary of each group. Questions are then answered from those summaries, not from single passages. Microsoft Research published the method in April 2024.

Tying a model's output to verifiable sources — retrieved documents, tool results, database records — so each claim can be traced back to something outside the model. Grounding is the mechanism; citation is the visible part of it.

Retrieval that runs keyword and semantic search together and merges the results. Semantic search understands meaning but is unreliable on the exact strings enterprises live on — a part number, an error code, a contract reference — where plain keyword matching is exact. Running both and combining the rankings covers what either misses alone.

A structured representation of entities and the relationships between them — this company owns that subsidiary, which holds this contract, which references that clause. Where retrieval finds passages that look relevant, a graph answers questions about how things connect.

An open-source package for building agentic RAG systems, started at IBM. It bundles three existing projects into one stack: Langflow to build and edit the flows, OpenSearch for hybrid search and vector storage, and Docling to parse documents. Every part is meant to be swapped — the model, the search engine, the wiring between them.

Retrieval that applies the asker's own access rights before deciding what the model may see. Without it, a search index built across everything the organization holds will happily surface a passage from a document the person asking was never cleared to open — and the model will summarize it for them in plain language.

A second pass that reorders retrieved results before they reach the model, using a slower and more accurate model than the one that fetched them. The first pass optimizes for recall over a large corpus; the reranker reads the shortlist properly and puts the genuinely relevant items at the top.

A pattern where the system searches your own content for passages relevant to a question, then puts them in the prompt. The model answers from the evidence supplied rather than from memory. It is the standard way to make a general model useful on private, current or regulated information, and the standard way to get citations.

A knowledge graph that also writes down what its own terms mean. Not only that this company owns that one, but what counts as a customer, that every subsidiary is a company, that "supplies" runs one way and not the other. That set of rules is called an ontology. It is written in a standard a machine can read, so software can work out facts nobody ever stored. Told that Santiago is a capital, and that capitals are cities, it knows Santiago is a city.

Search that matches on meaning rather than exact words, by comparing embeddings of the query and the content. It finds the right document when the user's vocabulary differs from the author's — and it can miss an exact identifier that keyword search would have found instantly.

Data generated by a model rather than collected from the world, used to augment scarce training sets, cover rare cases, or stand in for records that cannot leave a controlled environment. It is genuinely useful and it inherits every bias and blind spot of whatever produced it.

A store built to hold embeddings and find the nearest ones to a query fast. It is the index behind semantic search and retrieval, and it is increasingly a feature of databases you already run rather than a separate product you must buy.

The measured performance of the current process before AI — cycle time, error rate, cost per case, throughput. Captured before the build, not reconstructed afterwards from memory or from the best week anyone remembers.

A standardized public test used to compare models — reasoning, coding, retrieval, domain knowledge. Benchmarks are useful for tracking the frontier and weak evidence about your workflow, since a model tuned to score well on a public test has been optimized for that test, not your task.

Whether a model's stated confidence means anything. A well-calibrated system is right about 70% of the time when it says 70%. Base models are often reasonably calibrated. The alignment training that makes a model helpful and polite has been shown to make this worse, which is why a fluent, confident tone is not evidence of anything.

A fixed set of test cases with known-good outcomes, run automatically against the system so you can tell whether a change made it better or worse. Evals are to an AI feature what a test suite is to software, and they are the only way to upgrade a model without guessing.

The AWSM LABS framework for scoring an AI deployment on four instruments that measure different things: operational, financial, experiential and custodial. The discipline is not to average them. It is to find where they disagree. Agreement confirms what you already suspected; a wide spread shows you where the value is really sitting, or leaking.

The set of answers you have agreed are correct, against which a system's output is scored. It is produced by people, it costs real time to build, and it is the part of an evaluation most likely to be missing — which is why so many AI programs report accuracy figures with nothing underneath them.

Output that is fluent, plausible and wrong — an invented citation, a policy clause that does not exist, a number with no source. It is not a bug to be patched out but a property of systems that predict likely continuations, which is why the engineering response is grounding, validation and review rather than a fix.

Using one language model to score another model's output against a rubric. It lets you evaluate at a scale human review could never reach. On clear criteria it lines up reasonably well with human judgment. It also picks up the judge's own biases — toward length, toward confidence, toward its own house style.

Degradation in a deployed system's performance over time as the world moves away from the conditions it was built for — new products, new language, new customer behavior, or a provider updating the model underneath you. Nothing breaks; results quietly get worse.

A measure of how surprised a model is by text it did not generate — lower means it predicted the words better. It is the standard metric for comparing language models during training, and it says nothing about whether answers are correct, useful or safe.

The two halves of accuracy, which trade against each other. Precision is how much of what the system flagged was actually right; recall is how much of what was there it actually caught. A fraud check tuned for recall stops more fraud and more legitimate customers; tuned for precision it annoys fewer people and misses more fraud. F1 is their harmonic mean, useful as shorthand and misleading when the two costs differ.

Scoring an AI tool against one specific workflow instead of ranking tools in the abstract. The same tool can be excellent on one task and actively harmful on the next. AWSM RSRCH scores the pair on five dimensions: outcome efficacy, adoption velocity, integration fit, total cost of ownership and deployment risk.

The structures that determine who may deploy AI, on what, under what controls, and who answers for the outcome. In practice it is an inventory of what is running, a risk tier per system, named owners, documented evaluation, and monitoring after launch — not a policy document.

Consistent, unfair differences in how a system performs across groups of people. It comes from the training data, from how the goal was framed, or from how the output gets used. Bias can be measured — but only once you have decided in advance which differences would be unacceptable.

A lasting record of what the system did. It holds the inputs, the evidence it pulled, the model and prompt version, the tools it called, the output, and any human review. The point is that someone who was not there can rebuild the decision months later.

Where a piece of data came from, how it has been transformed since, and what you are permitted to do with it. Distinct from an audit trail, which records what your system did: provenance records what the data is and whether it should have been there at all.

Where data is physically processed and stored, and which jurisdiction's law therefore applies to it. For AI this covers prompts, retrieved documents, logs and any content retained for training — and the answers differ by provider, by product tier and by region.

The European Union's law on AI. It came into force in August 2024 and arrives in stages. It sorts systems into four risk levels — prohibited, high-risk, limited and minimal — and sets duties to match, with separate rules for general-purpose models. Bans and AI-literacy duties started in February 2025. Rules for general-purpose models followed in August 2025. Most high-risk requirements land in August 2026.

The ability to say why a system produced a particular output in terms a person can evaluate and, where required, contest. For modern models this is rarely a look inside the weights; it is the evidence, retrieved sources, inputs and rules surrounding the decision.

The European Union's General Data Protection Regulation, in force since May 2018. It governs how personal data is collected, used and stored. Article 22 gives people the right not to be subject to a purely automated decision that has legal or similar effects — the clause AI deployments hit first. Fines reach the greater of €20 million or 4% of worldwide annual turnover.

The international standard for managing AI, published in December 2023. It sets out how a company should build, run and keep improving an AI management system. Unlike a framework, an outside auditor can certify you against it.

A short standard document describing a model or AI system: what it is for, what it was evaluated on, how it performed, where it should not be used, and what is known about its limitations. The system-level equivalent of a datasheet.

One list of every model and version you are running. For each one: what it is, which version is live and where, who owns it, what it was tested against, and what it is approved to do.

A voluntary framework from the US National Institute of Standards and Technology, published in January 2023. It is built on four functions: Govern, Map, Measure, Manage. Together they cover finding and handling AI risk across a system's whole life. A companion profile for generative AI followed in July 2024.

Data that identifies a person, on its own or combined with other data you hold. The term is American and narrower than it sounds. European law says "personal data", which covers anything relating to an identifiable person — IP addresses and device IDs included. In an AI system it turns up in places nobody listed: prompts, retrieved documents, chat logs and test sets.

An attack in which instructions hidden in content the model reads — a web page, a document, an email, a calendar invite — are treated as commands. The model cannot reliably tell your instructions from text that merely looks like instructions, which makes this a design constraint rather than a bug to be patched.

AI tools used inside an organization without its knowledge or approval — personal accounts, unvetted browser extensions, features switched on inside software already deployed. It is usually a sign that the sanctioned path is slower than the work requires.

An audit report on how a supplier handles customer data, written by an accounting firm. It scores five trust criteria: security, availability, processing integrity, confidentiality and privacy. Type I checks the controls on a single date. Type II tests that they worked over a period, usually three to twelve months. It is an attestation, not a certification, and the company being audited picks the scope.

Running AI on infrastructure you control, inside a border you choose, under laws you answer to — the chips, the data, the model weights and whoever operates them. Nations use the term about national capability; companies use it about not being a tenant. It is a spectrum, not a switch: most who claim it own some layers and rent the rest.

The share of intended users genuinely using a deployed AI system for real work, as against licences issued or accounts activated. Measured properly it is depth and frequency per role, not a headline percentage.

How ready a company is to get value from AI — across its data, workflows, skills, governance and who owns it at the top. Maturity is always uneven. Most companies are further ahead in one function than the company-wide score suggests, and that gap is where the sequencing decision sits.

Overlapping AI subscriptions, licences and built-in features piling up across a company, bought team by team with nobody keeping a central list. The cost is rarely any one licence. It is paying twice for the same thing, data split across tools, and no one able to say what is running.

The choice between licensing an AI product, building a system you own, or switching on capability already sitting in software you pay for. The honest framing is three options, not two. The deciding question is whether the workflow sets you apart or is the same everywhere.

The work of getting people to actually use a new system — redefining roles, retraining, resetting expectations about what good work looks like, and deciding explicitly where the freed-up time goes. For AI it is heavier than for conventional software, because the tool changes judgment rather than just tooling.

The state in which AI pilots keep succeeding on their own terms and none reaches production. The usual causes are structural rather than technical: no named owner, no baseline to prove value against, unresolved data access, and no route through security and procurement.

Reusing the provider's processed form of a prompt prefix across requests, so a long system prompt, a policy document or a fixed set of examples is not re-processed every call. Cached input is billed at a substantial discount and returns faster.

The ceiling a provider puts on how much you can send — requests per minute, tokens per minute, concurrent jobs — enforced per account or per key. Separate from price: you can be willing to pay and still be refused.

The share of cases a system completes end to end with no human touching them. Borrowed from payments and back-office operations, where it has been the headline automation number for decades.

How long from starting work to the point where a business number measurably moves — not first demo, not launch. It is the metric that most cleanly separates AI programs that compound from ones that consume budget.

The unit cost model of a generative feature: tokens in plus tokens out, multiplied by price per token, multiplied by volume. Retrieved context, conversation history, reasoning steps and retries all count, which is why real cost per request is routinely several times the naive estimate.

Everything an AI system costs over its life. Licences and inference. Building it in, and the data work behind it. Evaluation, monitoring and human review. Retraining, and the eventual move off it. Model spend is usually a minority of the total, and almost always the only line in the business case.

The cost of leaving. For AI systems it accrues in specific, identifiable places: prompts tuned to one model's quirks, evals written against its outputs, fine-tunes that do not transfer, embeddings in a proprietary vector space, and agent tooling bound to one provider's interfaces.

Getting a system to pursue what its operator actually intends, rather than a proxy that merely correlates with it. A model optimized for the wrong objective can be entirely accurate and still wrong — it does the thing you measured instead of the thing you wanted.

The capability given up in exchange for safety and steerability. Training a model to refuse, hedge and stay on task also makes it more cautious on legitimate edge cases, and the cost shows up as over-refusal and blander output rather than as a visible switch.

A system that matches or exceeds human performance across essentially any cognitive task, rather than doing one thing well. There is no agreed definition and no agreed test, which is why credible people looking at the same systems disagree on how close it is — they are not measuring the same thing.

The research position that intelligence needs a body. What a system can learn is shaped by what it can sense and do, so a model that only reads and writes is missing something a model with hands and eyes has. The academic term, in use since the 1990s, for what industry started calling physical AI in 2024.

Abilities that show up in larger models and are missing from smaller ones, appearing all at once rather than improving bit by bit. The framing is contested. Schaeffer and colleagues showed in 2023 that some of it is an artifact of the scoring — measure the same runs with a continuous metric and the jump smooths out.

A robot shaped roughly like a person — two legs, two arms, hands. The case for the shape is that the world is already built for it: our doors, stairs, tools and benches need no changing. The case against is that legs are hard, expensive and mostly unnecessary when a wheeled base would do.

Getting a model to break its own rules through what the user types. Role-play framing, made-up scenarios, coded instructions, or simply wearing it down. This is not prompt injection. There the hostile instruction hides inside content the model reads on the user's behalf.

Research into what a model is actually computing inside — which features it holds and which circuits produce a given behavior. It is not the same as explainability. Explainability accounts for a decision after the fact, using evidence from outside the model. This tries to read the mechanism itself.

AI that senses the world, decides what to do, and then does it — through cameras, sensors, motors and grippers rather than through text on a screen. The output is a change in the world, not a document. Jensen Huang of Nvidia put the phrase into wide use at GTC in 2024, and it now covers self-driving vehicles, warehouse robots, drones and humanoids.

A system improving its own ability to improve itself, so each gain makes the next one easier and progress compounds rather than plateaus. The term does two very different jobs. In the research discussion it names a hypothetical fast takeoff, where a model redesigns its own architecture with no human in the loop. In practice today it describes something far more ordinary: models being used to help write training code, generate training data, and grade the next model's outputs — narrow, supervised loops with people at every gate.

Deliberately attacking your own system to find how it fails before someone else does — adversarial prompts, edge-case inputs, attempts to extract data or bypass policy. Distinct from evaluation, which measures whether it works on the cases you expect.

Measured relationships showing that model loss falls in a predictable way as compute, data and parameters go up. Kaplan and colleagues set them out in 2020. Hoffmann and colleagues revised the balance in 2022, showing that most models of the day were badly undertrained for their size.

A hypothetical system substantially beyond the best human performance across essentially all domains, including the ability to improve itself and to plan. It is a research and policy concept rather than a description of anything that exists.

The total arithmetic used to train a model, counted in floating-point operations. It is the closest thing the field has to one number for how costly and how capable a model is. That is why regulators reach for it: under the EU AI Act, a general-purpose model is presumed to carry systemic risk once training compute passes 10^25 FLOP.

An internal picture of how things work, good enough to predict what happens next. Push a glass and it falls. A system with one can try an action in its head before trying it for real. The idea is old — the psychologist Kenneth Craik described a "small-scale model" of the world in 1943 — and it now covers both hand-built physics simulators and models that learn to predict video.