Home
Reference / Glossary
The terms, in plain English
The vocabulary of agentic AI, defined the way we actually use it: no hype, no hand-waving.
Agents
- Agentic AI
- AI systems that don't just answer — they take actions toward a goal: planning steps, calling tools, observing results, and correcting course with limited human input. The shift from a chatbot that talks to a system that does.
- Agents
- A model wrapped in a loop that can use tools, keep state, and pursue a goal over many steps. Where a single prompt gives one answer, an agent decides what to do next, acts, checks the outcome, and repeats until the task is done.
- Autonomy
- How much an agent decides and does on its own without asking. Higher autonomy means fewer check-ins but more need for guardrails and review.
- Sub-Agent
- A second agent spawned by a main agent to handle a focused piece of work in its own isolated context, then report back. Keeps the main thread clean and lets several tasks run in parallel.
- Harness
- The scaffolding around a model that makes it an agent: the loop, the tool definitions, the prompt assembly, memory wiring, and safety checks. The model is the engine; the harness is the car built around it. Most of the engineering effort lives here.
- Agent Loop
- The repeating cycle an agent runs: read the goal, decide an action, run a tool, observe the result, then decide again until the task is done.
- Skill
- A packaged capability an agent can load on demand: instructions plus any tools or scripts for a specific job. Lets an agent specialise without bloating its core prompt.
- ReAct
- A common agent loop where the model alternates between reasoning about what to do next and taking an action, such as calling a tool, using each result to decide the following step. The pattern behind most tool-using agents.
- Planning
- An agent breaking a goal into an ordered set of steps before acting, then adjusting as results come in. The difference between a chatbot and an agent that gets things done.
- Multi-Agent Orchestration
- Coordinating several specialised agents — a planner, researchers, a reviewer — that work in parallel or hand off to each other. More reliable and scalable than asking one agent to do everything.
- Human-in-the-Loop
- A design where the agent pauses for a person to approve, edit, or reject a step before it continues. The standard safeguard for anything irreversible or high-stakes.
- Autonomy Levels
- How much an agent does without a human: from suggest-only, to act with approval, to fully autonomous. Most production setups sit in the middle.
Core
- Prompt
- The text you give a model to work from: the question, the instructions, and any context. Everything the model sees before it responds.
- System Prompt
- The standing instructions given to a model before any user message: its role, rules, tone, and which tools it can use. It shapes every reply in the session.
- Memory
- How an agent remembers across turns and sessions. Short-term lives in the context window; durable memory is stored externally (files, a database, a vector store) and recalled when relevant. The reliable path to long-horizon work — cheaper and more auditable than an ever-bigger context.
- Context Window
- The maximum amount of text (measured in tokens) a model can consider at once — prompt, history, retrieved docs, and the reply. Everything outside it is invisible to the model, which is why memory and retrieval matter.
- Token
- The unit models read and write — roughly a word-piece (about ¾ of a word in English). Context limits, latency, and pricing are all measured in tokens, so token efficiency is a real engineering lever.
- Streaming
- Returning a model's output token by token as it is generated, instead of waiting for the whole answer. Makes an agent feel responsive even on long replies.
- Temperature
- A setting that controls how random a model's output is. Low temperature gives focused, repeatable answers; high temperature gives more varied, creative ones.
- Guardrails
- The checks that keep an agent inside safe, intended bounds — input/output filters, permission gates, action limits, human-in-the-loop on risky steps. Non-negotiable for enterprise deployment.
- Prompt Caching
- Reusing the processed form of a repeated chunk of prompt, like a long system prompt or document, so the model does not pay to read it again. Cuts cost and latency on multi-turn or repeated calls.
- Compaction
- Summarising or trimming an agent's earlier conversation so a long-running task still fits inside the context window without losing the thread.
- Hallucination
- When a model states something false with full confidence. Inherent to how LLMs work; mitigated — not eliminated — with retrieval, citations, verification steps, and keeping a human in the loop where it counts.
Infra
- API
- An interface that lets one piece of software call another. For AI, it is how your app sends prompts to a model and gets responses back, billed per token.
- Webhook
- An automated message one service sends another the moment an event happens, so an agent can react in real time instead of polling for changes.
- Rate Limit
- A cap a provider puts on how many requests or tokens you can use in a window. Hit it and calls queue or fail until the window resets.
- MCP (Model Context Protocol)
- An open standard for connecting models to tools and data sources through a common interface, so a capability built once works across many agents and apps. The emerging "USB-C" for plugging context into AI.
- Embeddings
- Numeric vectors that capture the meaning of text, so similar ideas sit close together in space. The backbone of semantic search and retrieval — you compare meaning, not keywords.
- Vector Database
- A store built to index and search embeddings by similarity (pgvector, Pinecone, Weaviate). It's what lets an agent ask "what do I know that's relevant to this?" and get an answer in milliseconds.
- Latency
- The delay between sending a request and getting a response. Lower latency means a snappier agent; reasoning models and long contexts add to it.
- GPU
- The processor that does the heavy maths behind training and running models. The cost and availability of GPUs shape what is affordable to run, especially on-prem.
- Quantization
- Shrinking a model by storing its weights at lower precision (e.g. 4-bit), so it runs faster and fits smaller hardware with modest quality loss. Key to running capable open models locally and affordably.
- Sandbox
- An isolated environment where an agent can run code, browse, or execute commands without touching your real system. The safety boundary for autonomous work.
- Inference
- Running a trained model to get an output — the cost you pay per request, every request, forever. Inference economics (speed, price per token, hardware) often decide what's viable in production.
- Self-Hosting
- Running the software on your own machine or servers instead of a vendor's cloud, so your data, memory, and keys stay under your control.
Models
- LLM (Large Language Model)
- A neural network trained on vast text to predict the next token. That simple objective, at scale, yields models that write, reason, summarise, and code. The engine underneath nearly every modern AI product.
- Parameters
- The internal values a model learns during training, counted in the billions. More can mean more capable, but quality depends on training and data, not size alone.
- Models
- The trained networks themselves — GPT, Claude, Gemini, Llama, Mistral and the rest. They differ in capability, speed, cost, context size, and whether the weights are open or closed. Choosing the right one per task is half of building well.
- Multimodal
- A model that handles more than just text: images, audio, video, or documents as input or output. Lets an agent read a screenshot or a PDF, not only prose.
- Local / Open-Weight Models
- Models whose weights you can download and run on your own hardware (via Ollama, vLLM, llama.cpp). Trade some peak capability for privacy, control, predictable cost, and no data leaving your network — often decisive for enterprise.
- Frontier Model
- The most capable models available at any given moment, from the leading labs. They set the ceiling on what agents can reliably do, and the price for it.
- Distillation
- Training a smaller, cheaper model to copy the behaviour of a larger one, keeping much of the quality at a fraction of the cost to run.
- Mixture of Experts
- A model design that routes each input to a few specialised sub-networks instead of the whole model, giving large capacity at lower running cost.
Technique
- Prompt Engineering
- The craft of writing instructions that get reliable results from a model: structure, examples, and constraints. Less guesswork than it sounds, more repeatable than it looks.
- Zero-Shot / Few-Shot
- Asking a model to do a task with no examples (zero-shot) or a handful of examples (few-shot) in the prompt. Examples often lift accuracy with no retraining.
- Tool Use
- Giving a model the ability to call functions — search the web, query a database, run code, hit an API — and feed the result back into its reasoning. The bridge between a model that knows things and an agent that can do things.
- Chain-of-Thought
- Prompting a model to work through its reasoning step by step before giving an answer, which improves accuracy on multi-step problems. The basis of most reasoning modes.
- Function Calling
- A model capability where, instead of replying in prose, it returns a structured request to run a specific tool or function with given arguments. The mechanism behind tool use.
- Structured Output
- Forcing a model to answer in a fixed machine-readable shape, usually JSON, so software can use the result directly instead of parsing prose.
- RAG (Retrieval-Augmented Generation)
- Fetch relevant documents at query time and put them in the context so the model answers from your data, not just its training. The standard way to ground AI in private, current, or domain-specific knowledge and cut hallucination.
- Grounding
- Tying a model's answer to real source material, like your documents or live search, so it responds from facts instead of memory. The core idea behind RAG.
- Fine-Tuning
- Further-training a base model on your own examples to bake in a style, format, or task. Powerful but heavier than prompting or RAG — usually the last lever you reach for, not the first.
- Reasoning
- Models that "think" before answering — working through intermediate steps internally (chain-of-thought) to handle harder, multi-step problems. Trades extra tokens and latency for accuracy.
- Evals
- Structured tests that measure how well a model or agent performs on a task, so changes can be compared objectively instead of by feel.