AI Glossary

Name: Sistava
Price: 49 USD
Rating: 4.5 (6 reviews)

Plain-English definitions for 450 terms across AI agents, language models, memory, protocols, safety, and running agents in production. Every definition is on this page, and each term also has its own.

Agents and Architecture

Agent Architecture: Agent architecture is the arrangement of components that make an agent work: the model, the instructions, the tool layer, the memory and state stores, the control loop, and the guardrails. It describes how information flows between them and where each decision is made. Different architectures suit different tradeoffs between flexibility, cost, and predictability.
Agent Constitution: An agent constitution is a written set of principles that govern an agent's behavior, stating what it must always do, never do, and how to resolve conflicts between goals. In deployed systems it usually appears as durable instruction text and enforcement rules, distinct from the research method of training a model against a written set of principles.
Agent Framework: An agent framework is a class of software library or toolkit that provides the scaffolding for building systems in which a language model plans, calls tools, and acts over multiple steps. Typical components include a control loop, tool registration, state and memory handling, and observability hooks. Frameworks differ in how much control they take from application code.
Agent Loop: The agent loop is the repeating cycle at the center of every agent: assemble context, ask the model what to do, execute the chosen action, add the result to context, and repeat until a stopping condition is met. Stopping conditions include producing a final answer, hitting a step or budget limit, or requiring human approval.
Agent Memory: Agent memory is information deliberately retained across separate runs or conversations so an agent can recall facts, preferences, and past outcomes it was not given in the current request. It is stored outside the model, commonly in a database, vector index, or knowledge graph, and relevant pieces are retrieved and inserted into context before each step.
Agent Orchestration: Agent orchestration is the layer that decides which agent or step runs, in what order, with what inputs, and what happens when something fails. It covers routing, scheduling, retries, state passing, and concurrency limits. Orchestration is ordinary software rather than model output, which is what makes multi-step agent systems observable and recoverable.
Agent Persona: An agent persona is the defined role, voice, and scope given to an agent, covering what it is responsible for, how it communicates, and what it declines. It is expressed mainly in the system prompt and shapes both output style and behavior, because a clearly bounded role improves tool selection and reduces answers outside the agent's remit.
Agent Planning: Agent planning is the process by which an agent works out an ordered set of steps to reach a goal before, or while, carrying them out. Plans may be produced once at the start, revised after each observation, or replaced entirely when new information arrives. Planning quality is a common bottleneck, because a confident plan built on a wrong assumption fails at every step.
Agent Role: An agent role is the scoped function assigned to an agent within a system, defining what it is responsible for, which tools and data it may access, and what it must hand off to others. Roles are structural boundaries rather than descriptive labels, and they are most useful when access permissions actually follow them.
Agent Run: An agent run is one bounded execution of an agent from trigger to termination, containing every step, tool call, and intermediate result produced along the way. It is the standard unit for measuring cost, duration, and success, and it is what logging, replay, and evaluation systems are usually built around.
Agent Skill: An agent skill is a packaged unit of instruction that teaches an agent how to perform a particular kind of task, typically containing procedures, conventions, and references, and loaded into context only when relevant. Skills keep the base prompt small while making specialized know-how available on demand. The term is used differently across frameworks, so the details vary.
Agent State: Agent state is the information an agent carries through a single run: the conversation so far, intermediate results, the current plan, pending approvals, and progress markers. It lives in the runtime rather than inside the model, because a model holds nothing between calls. Durable state is what lets a run pause, resume, or be inspected after the fact.
Agent Swarm: An agent swarm is a multi-agent arrangement in which many peer agents work on a shared goal without a central controller, coordinating through local interaction or a shared medium rather than through a directing supervisor. Global behavior emerges from local decisions, which makes swarms flexible but harder to predict and audit than hierarchical designs.
Agent Trajectory: An agent trajectory is the complete recorded sequence of a single run: every model input, decision, tool call, result, and error, in order. It is the primary artifact for debugging, evaluation, and audit, because the final answer alone does not reveal how it was produced. Trajectories also show whether an agent took a sensible route, not just whether it finished.
Agentic AI: Agentic AI is an umbrella term for AI systems that pursue goals through multiple steps and actions rather than producing a single response. It describes an approach rather than a specific technology, covering anything from a model that calls one tool to a coordinated set of agents. The term is marketing-heavy and its boundaries are not agreed on.
Agentic Workflow: An agentic workflow is a defined sequence of work in which one or more AI agents carry out steps, with the surrounding structure specifying the order, the inputs, and the checkpoints. It sits between a rigid automation script and a fully open-ended agent, because the shape of the work is fixed while the content of each step is decided at runtime.
AI Agent: An AI agent is a software system that uses a language model to decide what actions to take toward a goal, then carries those actions out through tools such as APIs, databases, or a browser. Unlike a single question and answer exchange, an agent runs over multiple steps, observing results and adjusting until the goal is met or it stops.
Autonomous Agent: An autonomous agent is an AI agent that can start, continue, and finish work without a person approving every step. Autonomy is a spectrum rather than a switch, and it is usually bounded by explicit limits on which tools the agent may use, how much it may spend, and which actions require approval before they take effect.
Autonomy Level: Autonomy level describes how much an agent may do without human involvement, from suggesting an action, to acting with approval, to acting freely within limits and reporting afterward. There is no single industry standard scale, so specific levels are defined per system. Levels are usually assigned per action type rather than to the agent as a whole.
Blackboard Architecture: A blackboard architecture is a coordination pattern in which independent components read from and write to a shared, structured data store rather than calling one another directly. Each component watches the store for conditions it can act on, contributes its result, and lets other components build on that contribution, with a control mechanism deciding who acts next.
Chain of Thought: Chain of thought is the practice of having a language model produce intermediate reasoning steps before its final answer, rather than jumping straight to a conclusion. It measurably improves accuracy on multi-step problems such as arithmetic, logic, and planning. The written steps are an output of the model, not a transcript of how it actually computed the answer.
Checkpointing: Checkpointing is the practice of persisting an agent's state at defined points during a run so that execution can resume from the last saved point after an interruption, rather than restarting from the beginning. It underpins long running agents, human approval pauses, and recovery from process crashes or deployments.
Confidence Threshold: A confidence threshold is a cutoff value that determines whether an agent acts on a result automatically or routes it for review. It requires a confidence signal that actually correlates with correctness, and a language model's own stated confidence is a weak signal, since models are frequently confident and wrong.
Context Engineering: Context engineering is the practice of deciding what information occupies an agent's context window at each step, including instructions, retrieved documents, tool definitions, prior messages, and working state. It treats the context window as a scarce resource to be curated deliberately rather than as a buffer that accumulates everything the run has touched.
Delegation: Delegation is when one agent assigns a subtask to another agent and remains responsible for the outcome. The delegating agent frames the request, supplies the context the other will need, and receives a result to check and integrate. It differs from a handoff, where responsibility for the interaction transfers away and does not return.
Deterministic Replay: Deterministic replay is the reconstruction of a past agent run by replaying its recorded inputs, model outputs, and tool results in the original order, rather than re-executing the model and tools live. It makes a nondeterministic run reproducible for debugging, since the recorded outputs are fixed instead of being sampled again.
Deterministic vs Probabilistic Behavior: Deterministic behavior produces the same output for the same input every time, while probabilistic behavior samples from a distribution and may differ between runs. Language models are probabilistic by default, so agents built on them are not reproducible in the way ordinary software is. Reliable systems place deterministic code around probabilistic decisions rather than trying to remove the variability.
Escalation Policy: An escalation policy defines when an agent must stop acting on its own and route a decision to a person or a higher authority agent. It specifies the triggering conditions, who receives the request, what context accompanies it, and what the agent does while it waits, including whether the run pauses or continues on other work.
Event-Driven Agent: An event-driven agent starts in response to something happening, such as an incoming message, a webhook, a record changing, or a threshold being crossed. Its trigger carries the initial context, and its value is responding close to the moment the event occurs. Volume is unpredictable, so limits and deduplication matter more than in scheduled work.
Fallback Behavior: Fallback behavior is what an agent does when its intended path is unavailable, such as a failed tool, an unreachable model, an exhausted budget, or a result below a confidence threshold. A defined fallback makes failure predictable, whereas an undefined one leaves the agent to improvise, which commonly produces a fabricated answer.
Guard Condition: A guard condition is a check evaluated before an agent action is allowed to proceed, blocking it when the check fails. Guards are enforced by the runtime rather than by the model, which makes them effective against reasoning errors, ambiguous instructions, and injected instructions alike.
Handoff: A handoff is the transfer of an in-progress task or conversation from one agent to another, or from an agent to a person, along with the context needed to continue. Unlike delegation, responsibility moves and typically does not return. Handoffs are common in support routing, escalation, and specialist agent designs.
Human in the Loop: Human in the loop describes an agent design in which a person reviews, approves, corrects, or supplies input at defined points before the system proceeds. It is typically applied to actions that are costly or hard to reverse, such as sending external messages, changing records, or spending money. The pause is enforced by the runtime, not requested by the model.
Multi-Agent System: A multi-agent system is one in which several AI agents, each with its own instructions, tools, and scope, work on parts of a larger goal and exchange information. Agents may run in sequence, in parallel, or under a coordinator. The design trades the simplicity of one agent for specialization, isolation of context, and parallel progress.
Plan And Execute Pattern: Plan and execute is an agent design in which a planning step produces an explicit multi-step plan up front, and a separate execution step carries out those steps in order, optionally replanning when a step fails. It contrasts with interleaved designs that decide only the next single action after observing the previous result.
ReAct Pattern: ReAct, short for reasoning and acting, is an agent pattern in which the model alternates between writing out a thought about what to do next and taking an action such as a tool call, then observing the result before thinking again. Introduced in a 2022 research paper, it became the default shape for tool-using agents.
Reasoning Model: A reasoning model is a language model trained to spend additional computation on internal deliberation before answering, typically producing extended intermediate reasoning that may be hidden from the caller. Several major providers offer such models alongside faster general-purpose ones, often with a setting controlling how much reasoning effort to spend. They cost more and respond more slowly.
Recursion Limit: A recursion limit is the maximum nesting depth allowed when agents create other agents, or when a graph based agent revisits the same node. It prevents unbounded delegation chains where each agent spawns another, and it is enforced by the runtime rather than by any single agent's judgment.
Reflection Pattern: The reflection pattern is an agent design in which a first pass output is fed back for explicit criticism, and the criticism is then used to produce a revised output. The critique may come from the same model in a separate call, a different model, or an automated check such as a compiler, test suite, or validator.
Scheduled Agent: A scheduled agent runs on a time-based trigger such as an hourly, daily, or weekly schedule, rather than in response to a request. Nobody is present when it starts, so it must determine its own context, decide whether there is anything to do, and route its output somewhere a person will see it later.
Self-Consistency: Self-consistency is a technique that samples several independent reasoning paths for the same question and selects the answer that appears most often, rather than trusting a single generated chain. It exploits the observation that correct answers tend to be reached by many different valid routes, while errors are more scattered across sampled outputs.
Shared Scratchpad: A shared scratchpad is a mutable working area that several agents, or several steps of one agent, can read and write during a task. It holds intermediate notes, partial results, and open questions that would otherwise be lost between steps, and it is normally discarded when the task ends rather than persisted as long term memory.
Stateful vs Stateless Agent: A stateless agent handles each request independently, retaining nothing between invocations, while a stateful agent carries information forward across steps or sessions through stored conversation history, memory, or working state. The distinction determines whether identical inputs produce comparable behavior and how much infrastructure a deployment requires.
Step Budget: A step budget is the maximum number of actions, usually model calls or tool invocations, that an agent may take within a single run. It bounds the cost and duration of any one execution, converting a potentially unbounded loop into a run whose worst case is known before it starts.
Subagent: A subagent is an agent instance created by another agent to carry out a bounded part of a larger task and return a result to its caller. It usually receives its own instructions, tool set, and context window, and its intermediate steps stay hidden from the parent, which observes only the returned output.
Supervisor Agent: A supervisor agent is an agent whose job is to coordinate other agents rather than to do the work itself. It interprets the goal, decides which specialist should act next, passes along the necessary context, and decides when the overall task is complete. It is the most widely used arrangement in multi-agent systems.
Task Decomposition: Task decomposition is breaking a large or vague request into smaller, concrete subtasks that can be executed and checked one at a time. In agent systems the split may be written by a developer, produced by the model at runtime, or a mix of both. Good decomposition produces subtasks with clear inputs, clear completion criteria, and few dependencies.
Termination Condition: A termination condition is the rule that ends an agent's execution loop. It may be satisfaction, meaning the agent judges the goal complete, or exhaustion, meaning a limit on steps, time, cost, or consecutive failures was reached. Every autonomous loop needs at least one exhaustion condition, because satisfaction alone can never be guaranteed to trigger.
Tool Error Recovery: Tool error recovery is how an agent responds when a tool call fails, times out, returns unexpected data, or is rejected. It covers whether the failure is surfaced to the agent as an observation, how the agent is expected to react, and what limits prevent it from retrying the same failing call indefinitely.
Tool Selection: Tool selection is the decision an agent makes about which available tool, if any, to invoke at a given step. It depends on the tool descriptions the agent can see, the task at hand, and the state of the current run, and its accuracy degrades as the number of similar or overlapping tools grows.
Tool Use: Tool use is an agent's ability to invoke external functions such as search, database queries, file operations, or third-party APIs, and to incorporate the results into its next decision. The model does not run the tool itself. It emits a structured request naming the tool and its arguments, and the surrounding runtime executes it and returns the output.
Tree Of Thoughts: Tree of thoughts is a reasoning method in which a model generates several candidate intermediate steps at each stage, evaluates how promising each one is, and searches the resulting tree with strategies such as breadth first or depth first exploration, including backtracking. It generalizes single path step by step reasoning into a deliberate search over alternatives.
Wake Condition: A wake condition is the rule that causes an idle agent to begin a run. It may be a schedule, an incoming event such as a message or webhook, a state change detected by polling, or a threshold crossing in monitored data, and it determines both how promptly an agent responds and how much it costs while nothing is happening.

Models and Prompting

Artificial General Intelligence: Artificial general intelligence is a hypothetical form of artificial intelligence able to learn and perform the full range of intellectual tasks that people can perform, rather than excelling only in narrow domains. The term is contested, because researchers disagree about what counts as general capability and about how it would be measured. No agreed definition or accepted test exists.
Attention Mechanism: An attention mechanism is a neural network component that lets a model weigh which parts of its input matter most when computing each part of its output. Instead of compressing a whole sequence into one fixed representation, attention computes a set of relevance scores and forms a weighted blend of the input positions. It is the core building block of transformer architectures.
Beam Search: Beam search is a decoding strategy that maintains several candidate sequences in parallel, extending each by the most likely next tokens and keeping only the top scoring candidates at every step. The number retained is called the beam width. It finds higher-probability sequences than greedy decoding at proportionally higher compute cost.
Benchmark: A benchmark is a standardized set of tasks used to measure and compare model capability, such as graduate-level science questions, competition mathematics, or resolving real software issues. Scores from these sets are widely quoted in model announcements. They are useful for coarse comparison and are weak predictors of performance on any particular real workload.
Chain of Thought Prompting: Chain of thought prompting asks a model to work through intermediate steps before giving a final answer, rather than answering immediately. Producing those steps improves accuracy on arithmetic, logic, and multi-step tasks, because each generated step becomes context for the next. The gain comes from the extra computation the steps allow, not from the model narrating a real internal process.
Computer Vision: Computer vision is the field concerned with extracting information from images and video so that software can describe or act on visual content. Typical tasks include classifying an image, detecting and locating objects, segmenting regions at the pixel level, tracking motion across frames, and reconstructing three dimensional structure. Modern systems are dominated by learned models rather than hand written rules.
Constitutional AI: Constitutional AI is a training method in which a model's behavior is shaped by an explicit written set of principles, called a constitution, instead of relying solely on case-by-case human judgments. The model critiques and revises its own responses against those principles, and the revised outputs become training data. The approach makes the values guiding behavior inspectable and editable.
Context Window: The context window is the maximum number of tokens a model can consider in a single request, counting the prompt, any attached documents, the conversation so far, and the response it generates. Anything outside that budget is simply not available to the model. Limits range from a few thousand tokens in older models to over a million in some current ones.
Data Contamination: Data contamination is the presence of evaluation material in a model's training data, which inflates measured performance because the model has effectively seen the answers. It is widespread with web-scraped corpora, since public benchmarks and their solutions are published online. Contamination makes reported scores unreliable as evidence of generalization.
Decoder-Only Model: A decoder-only model is a transformer architecture built from a single stack of causally masked layers that predicts each token from the tokens before it. It has no separate encoder, so input and output occupy the same sequence and the same processing path. Most contemporary text generation systems use this architecture.
Deep Learning: Deep learning is a subfield of machine learning that uses neural networks with many layers of processing units to learn representations directly from raw data. Each layer transforms the output of the previous one, allowing later layers to encode increasingly abstract features. This layered structure underpins most modern speech, image, and language systems.
Diffusion Model: A diffusion model is a generative system trained to reverse a gradual noising process. During training it learns to remove noise from corrupted data; during generation it starts from pure noise and denoises step by step until a coherent sample emerges. Diffusion is the dominant approach for image, video, and audio generation.
Embedding Model: An embedding model converts text, images, or other data into a fixed-length list of numbers, called a vector, that represents meaning. Items with similar meaning land close together in that numeric space, so similarity can be measured arithmetically. Embeddings underpin semantic search, recommendation, clustering, deduplication, and the retrieval step in retrieval-augmented generation.
Emergent Ability: An emergent ability is a capability that appears in larger models but is absent or near random in smaller ones of the same family, seemingly arriving abruptly rather than improving gradually with scale. Reported examples include multi-step arithmetic and certain instruction-following behaviors. Whether such jumps are genuine phase transitions or artifacts of how performance is measured is actively disputed.
Encoder-Decoder Model: An encoder-decoder model is an architecture with two components: an encoder that reads the entire input bidirectionally into a set of representations, and a decoder that generates output while attending to those representations. It was designed for tasks that map one sequence to another, such as translation. It remains common in speech, translation, and some structured transformation systems.
Few-shot Prompting: Few-shot prompting supplies several worked examples of a task inside the prompt so the model can infer the pattern before handling the real input. No parameters change and nothing persists after the request finishes. The technique is also called in-context learning, because the model appears to learn the task from the surrounding context alone.
Fine-tuning: Fine-tuning continues training an already-trained model on a smaller, targeted dataset so it performs better on a specific task, domain, or format. It changes the model's parameters, which distinguishes it from prompting. Typical uses include enforcing a house style, matching a rigid output schema, or teaching specialized terminology that appears rarely in general training data.
Foundation Model: A foundation model is a large model trained once on broad, general data and then adapted to many different downstream tasks rather than built for a single purpose. Language models, image models, and speech models can all be foundation models. The defining trait is reuse: one expensive training run produces a general base that many separate applications adapt cheaply.
Frontier Model: A frontier model is one of the most capable general-purpose models available at a given time, typically trained at the largest scale currently feasible. The term is used in policy and safety discussion to designate systems whose capabilities are not yet well characterized and may pose novel risks. Its boundary is relative and shifts as the field advances.
Generative AI: Generative AI is a class of machine learning systems that produce new content such as text, images, audio, video, or code, rather than only labeling or scoring data that already exists. These systems learn statistical patterns from large training corpora and then sample fresh outputs consistent with those patterns. The category spans language models, image diffusion models, and speech synthesis systems.
Greedy Decoding: Greedy decoding is a text generation strategy that selects the single highest-probability token at every step, with no randomness and no lookahead. It is deterministic, so the same input and model produce the same output every time. It is the simplest decoding method and is equivalent to sampling at a temperature of zero.
Inference: Inference is the act of running a trained model to produce output, as distinct from training, which creates the model. During inference the parameters are frozen and no learning occurs. Every request sent to a deployed model is an inference call, and inference is where the ongoing operational cost of running a model accumulates over its lifetime.
Instruction Tuning: Instruction tuning is the training stage that teaches a base model to follow written instructions and answer in a helpful assistant format. It uses a curated set of instruction and response pairs covering many task types. This stage converts a model that merely continues text into one that responds to requests, and it normally precedes preference-based alignment.
Intent Classification: Intent classification is a natural language processing task that assigns an incoming message to one of a predefined set of purposes, such as booking, canceling, or requesting a refund. It converts free text into a routing decision that downstream logic can act on. The label set is designed for a specific application, and unfamiliar requests must be handled explicitly.
Knowledge Distillation: Knowledge distillation is a training technique in which a smaller student model learns to reproduce the behavior of a larger teacher model. The student trains on the teacher's outputs, which may be full probability distributions, generated text, or intermediate representations, rather than only on ground-truth labels. The goal is a compact model that retains much of the teacher's capability.
KV Cache: A KV cache is the stored set of key and value tensors computed for tokens already processed during generation, kept in memory so they do not have to be recomputed for each new token. It converts generation from a repeated full-sequence computation into an incremental one. Its memory footprint grows with sequence length and is a primary limit on serving capacity.
Large Language Model: A large language model is a statistical model trained on very large amounts of text to predict the next piece of text in a sequence. That single objective, applied at scale, produces systems that can answer questions, write and summarize documents, translate, and generate code. The model stores what it learned in billions of numeric weights rather than in a searchable database of documents.
Low-Rank Adaptation: Low-rank adaptation is a parameter-efficient fine-tuning method that freezes a model's original weights and learns a small pair of matrices whose product forms a correction to selected weight matrices. Because the correction is constrained to a low rank, it holds far fewer trainable values than the weights it modifies. It is the most widely used adapter technique for large models.
Machine Learning: Machine learning is a branch of artificial intelligence in which systems derive rules from data rather than following instructions written by a programmer. A learning algorithm adjusts internal parameters so that a model's outputs better match patterns observed in examples. The resulting model can then make predictions or decisions about data it has not seen before.
Max Tokens: Max tokens is a request parameter that caps how many tokens a model may generate in a single response. Reaching the cap stops generation abruptly, potentially mid-sentence, and the response is reported as truncated by length. It bounds output cost and latency but is distinct from the model's total context window.
Mixture of Experts: Mixture of experts is a model architecture that splits part of the network into many specialized sub-networks, called experts, and routes each token to only a few of them. This lets a model hold a very large total parameter count while activating a small fraction for any given token, giving the capacity of a big model at closer to the compute cost of a smaller one.
Model Card: A model card is a structured document that describes a model's intended uses, training approach, evaluation results, limitations, and known risks. It accompanies a released model so that adopters can judge fitness for their purpose without reverse-engineering behavior. The format was proposed to make responsible disclosure a routine part of model release.
Model Routing: Model routing directs each request to a suitable model instead of sending everything to one. A router may classify difficulty, apply rules by task type, or try a cheap model first and escalate when confidence is low. The goal is to cut cost and latency on easy requests while preserving quality on the hard ones.
Multimodal Model: A multimodal model accepts or produces more than one type of data, such as text together with images, audio, or video. Inputs from each modality are converted into a shared internal representation so the model can relate them, for example answering a question about a photograph. Most widely used assistants now accept images alongside text and reply in text.
Named Entity Recognition: Named entity recognition is a natural language processing task that locates spans of text referring to specific things and assigns each a type, such as person, organization, location, date, or monetary amount. It converts unstructured text into structured fields that other systems can filter, index, or store. Type schemes are defined per application rather than being universally fixed.
Narrow AI: Narrow AI, also called weak AI, refers to systems built and trained to perform a specific task or a bounded set of tasks, such as recognizing faces, ranking search results, or transcribing speech. Performance can be very high inside that scope and typically degrades sharply outside it. Every artificial intelligence system in production use today is narrow in this sense.
Natural Language Processing: Natural language processing is the field concerned with enabling computers to analyze, interpret, and generate human language. It covers tasks such as translation, summarization, question answering, sentiment analysis, and speech transcription. Approaches have moved from hand written grammatical rules to statistical models and then to large neural models trained on very large text collections.
Neural Network: A neural network is a mathematical model made of layers of simple units, each computing a weighted sum of its inputs followed by a nonlinear function. Learning consists of adjusting those weights so that the network's outputs match examples in training data. Networks with many stacked layers are called deep, which is where the term deep learning comes from.
Open-weight Model: An open-weight model is one whose trained parameters are published for download, so anyone can run it on their own hardware, inspect it, and adapt it. Open weights are not the same thing as open source, since training data and code are usually withheld and licenses often restrict certain uses. The distinction matters legally and is frequently blurred in coverage.
Parameter-Efficient Fine-Tuning: Parameter-efficient fine-tuning is a family of adaptation methods that adjust a small number of parameters while leaving most of a pre-trained model's weights frozen. It achieves much of the benefit of full fine-tuning at a fraction of the memory and storage cost. Common approaches include low-rank adapters, prefix tuning, and bias-only updates.
Parameters: Parameters are the numeric values inside a model that are adjusted during training and then held fixed when the model is used. They are where everything the model learned is stored. Model size is usually quoted as a parameter count, such as eight billion or several hundred billion, and that number strongly influences memory requirements and running cost.
Perplexity: Perplexity is a metric for how well a language model predicts a body of text, computed as the exponential of the average negative log probability the model assigns to each token. Lower values mean the model found the text less surprising. It is the standard intrinsic measure used during pre-training and for comparing models on the same evaluation data.
Positional Encoding: Positional encoding is the technique of injecting information about token order into a transformer, which otherwise treats its input as an unordered set. The encoding is added to or applied over token representations so that the model can distinguish sequences that contain the same tokens in different arrangements. Several schemes exist, including fixed sinusoidal patterns, learned embeddings, and rotary methods.
Pre-training: Pre-training is the first and largest stage of building a model, in which it learns general patterns from a very large unlabeled corpus, typically by predicting the next token. It produces a base model with broad knowledge and language ability but no particular tendency to follow instructions. Later stages then adapt that base into a usable assistant.
Prompt: A prompt is the complete input given to a model for one request. It usually combines several parts: instructions describing the task, any supplied context or documents, examples, the conversation history, and the user's actual question. The model receives all of this as one sequence of tokens, with no inherent boundary between the parts beyond what its training taught it to expect.
Prompt Chaining: Prompt chaining is the practice of decomposing a task into a sequence of separate model calls, where the output of one call becomes part of the input to the next. Each step handles a narrower subtask than the whole. Chaining trades additional calls and latency for higher reliability, easier debugging, and per-step validation.
Prompt Engineering: Prompt engineering is the practice of designing and refining the input to a model to get more reliable output. It covers wording instructions precisely, supplying examples, specifying output format, decomposing a task into steps, and testing variants against measured results. It works because a model's behavior is highly sensitive to how a request is framed and structured.
Prompt Template: A prompt template is a reusable prompt structure with placeholders that are filled with variable data at request time. It separates the fixed instructions, formatting rules, and examples from the changing input, so the same tested prompt serves many cases. Templates are the standard way prompts are managed in production systems.
Quantization: Quantization stores a model's parameters at lower numeric precision, for example using eight-bit or four-bit integers instead of sixteen-bit floating point numbers. This shrinks memory use roughly in proportion to the bit reduction and usually speeds up inference. Accuracy declines with it, typically slightly at eight bits and more noticeably at four bits and below.
Reasoning Effort: Reasoning effort is a setting on reasoning-capable models that controls how much internal deliberation a model performs before answering. Higher settings let it generate more hidden reasoning tokens, which improves accuracy on hard problems while increasing latency and cost. Providers expose it either as named levels such as low, medium, and high, or as a numeric token budget.
Reinforcement Learning: Reinforcement learning is a machine learning approach in which an agent learns by interacting with an environment and receiving numerical rewards for the outcomes of its actions. The goal is a policy, meaning a mapping from observed states to actions, that maximizes cumulative reward over time. Learning proceeds through trial, feedback, and revision rather than from labeled examples.
Reinforcement Learning From AI Feedback: Reinforcement learning from AI feedback is a training approach in which preference judgments used to shape a model's behavior come from another model rather than from human annotators. A judging model compares candidate responses against stated principles, and those comparisons train a reward signal or directly optimize the target model. It is used to scale preference training beyond what human labeling can cover.
Reinforcement Learning from Human Feedback: Reinforcement learning from human feedback is a training method that shapes a model's behavior using human judgments about which of several candidate responses is better. Those comparisons train a reward model, which then guides further optimization of the language model itself. It is the main technique behind the helpful, cautious tone that most commercial assistants share.
Scaling Law: A scaling law is an empirical relationship describing how a model's loss improves as a power function of model size, training data volume, and compute. These relationships have held across many orders of magnitude, allowing researchers to predict the performance of a large training run from much smaller experiments. They guide how a fixed compute budget is split between parameters and data.
Self-Attention: Self-attention is an attention mechanism in which a sequence attends to itself, so every position computes its representation by weighing all other positions in the same sequence. Queries, keys, and values all come from one input rather than from separate sources. It allows a model to build context-sensitive representations of each token based on its surroundings.
Sentiment Analysis: Sentiment analysis is a natural language processing task that assigns an evaluative orientation to text, most often positive, negative, or neutral, and sometimes a numeric intensity or a set of emotion categories. It is applied to reviews, survey responses, support messages, and social posts. Results describe expressed language, which does not always match what a writer actually feels.
Small Language Model: A small language model is a language model with a modest parameter count, often in the range of one to roughly fifteen billion, designed to run cheaply, quickly, and sometimes on a single device. It trades broad general capability for lower latency, lower cost, and easier deployment. The boundary with large models is conventional and shifts as hardware improves.
Speculative Decoding: Speculative decoding is an inference optimization in which a small fast model drafts several tokens ahead and a larger target model verifies them in a single parallel pass. Accepted draft tokens are kept and the first rejected one is corrected by the target model. It speeds up generation without changing the output distribution of the target model.
Stop Sequence: A stop sequence is a string that causes a model to halt generation as soon as it is produced. The matched text is normally excluded from the returned output. Stop sequences give the caller control over where a response ends, independent of the model's own end-of-turn signal or the maximum token limit.
Supervised Learning: Supervised learning is a machine learning approach in which a model is trained on examples that pair an input with the correct output, called a label. During training the model adjusts its parameters to reduce the difference between its predictions and those labels. Once trained, it assigns outputs to new inputs that were never labeled.
Synthetic Data: Synthetic data is training data generated by a model or a program rather than collected from human-produced sources. It is used to cover cases real data lacks, to scale instruction and preference datasets, and to avoid privacy or licensing constraints on real records. Its value depends heavily on generation quality and on filtering the results.
System Prompt: A system prompt is a set of instructions supplied separately from the user's message that defines a model's role, rules, tone, and boundaries for a conversation. It is sent with every request and normally stays hidden from the end user. Models are trained to give it higher priority than user messages, though that priority is a tendency rather than a guarantee.
Temperature: Temperature is a setting that controls how random a model's output is. At each step the model produces a probability for every possible next token, and temperature reshapes that distribution before one token is chosen. Low values concentrate probability on the most likely candidate, producing consistent output, while high values flatten it and admit less likely choices.
Token: A token is the unit of text a language model actually reads and writes. It is usually a common word, a word fragment, a punctuation mark, or a space plus a word. Models process sequences of tokens rather than characters or whole words, and usage is normally metered per token, so token counts determine both cost and how much fits in one request.
Tokenization: Tokenization is the step that converts raw text into the sequence of tokens a model can process, and converts the model's output back into text. Modern systems use subword algorithms that learn a fixed vocabulary from training data, keeping frequent words whole and splitting rare ones into pieces. It happens before any model computation and is invisible in the final result.
Top-p Sampling: Top-p sampling, also called nucleus sampling, limits the model's choice at each step to the smallest set of candidate tokens whose probabilities add up to a threshold p. One token is then drawn from that set alone. Unlike a fixed cutoff, the set size adapts: it stays small when the model is confident and grows when many continuations are plausible.
Training Data: Training data is the collection of text, code, images, or other content a model learns from during training. Its composition, quality, filtering, and licensing shape what a model knows, how it writes, and which biases it carries. Data selection is now regarded as comparable in importance to architecture and scale.
Transfer Learning: Transfer learning is the practice of reusing a model trained on one task or dataset as the starting point for a different, usually narrower task. Rather than learning from random initialization, the new task inherits representations already learned from broad data. It is the general principle that makes the pre-train then adapt pipeline possible.
Transformer: The transformer is the neural network architecture behind nearly all current language models. Introduced in a 2017 research paper, it processes a whole sequence at once and uses a mechanism called attention to let every position weigh the relevance of every other position. That design parallelizes well on modern hardware, which is what made training on internet-scale text practical.
Turing Test: The Turing test is a proposed criterion for machine intelligence, introduced by Alan Turing in 1950 as the imitation game, in which a human judge holds text conversations with a person and a machine and tries to tell them apart. If the judge cannot reliably do so, the machine is said to pass. Its status as a measure of intelligence is contested.
Unsupervised Learning: Unsupervised learning is a machine learning approach that finds structure in data carrying no labels. Instead of predicting a known answer, algorithms group similar items, reduce dimensionality, estimate density, or detect items that do not fit the observed pattern. Results describe the data rather than being correct or incorrect against a supplied target.
Zero-shot Prompting: Zero-shot prompting asks a model to perform a task from instructions alone, with no worked examples included in the prompt. It relies on abilities acquired during pre-training and instruction tuning. Modern instruction-tuned models handle a wide range of common tasks this way, which keeps prompts short and cheap, though results vary more on unusual output formats.

Memory and Knowledge

Agentic Retrieval: Agentic retrieval lets a model decide for itself whether to search, what to search for, and when it has enough evidence, instead of running one fixed retrieval before every answer. The model can issue several searches in sequence, refine queries based on what came back, and choose among different sources or tools.
Approximate Nearest Neighbor Search: Approximate nearest neighbor search is a family of algorithms that find vectors close to a query vector without guaranteeing that the very closest ones are returned. By tolerating a small chance of missing a true neighbor, these methods answer queries over millions of vectors in milliseconds instead of comparing the query against every stored record.
BM25: BM25 is a ranking function that scores how well a document matches a keyword query, based on how often query terms appear in the document, how rare those terms are across the collection, and how long the document is. Developed from probabilistic retrieval research in the 1990s, it remains the default lexical baseline in search engines and retrieval benchmarks.
Chunk Overlap: Chunk overlap is the practice of repeating a portion of text at the end of one chunk and the start of the next, so a passage split across a boundary still appears intact somewhere. Overlap is usually expressed as a token or character count, commonly ten to twenty percent of chunk size. It costs storage and duplicate results.
Chunking: Chunking is the process of splitting documents into smaller passages before they are embedded and indexed. Chunk size and boundary choice determine what a retriever can return, since retrieval operates on whole chunks. Passages that are too large dilute meaning and waste context, while passages that are too small lose the surrounding information needed to interpret them.
Citation: A citation is a reference attached to a generated statement that identifies the source passage supporting it, usually as a document title, link, or passage identifier. Citations let a reader verify a claim, and they let a system be audited when an answer later turns out to be wrong.
Context Injection: Context injection is the practice of inserting relevant information into a model's prompt before it generates a response, such as retrieved passages, user profile facts, the current date, or tool schemas. Because the model only sees what the prompt contains, injection is how an application determines what the model knows for that call.
Context Precision: Context precision measures what share of the retrieved passages placed in a prompt are actually relevant to the question, and whether the relevant ones appear near the top. It penalizes padding a prompt with loosely related material. High recall with low context precision means the answer is buried in noise the model must ignore.
Contextual Retrieval: Contextual retrieval prepends a short, generated description of a chunk's surrounding document to that chunk before it is indexed. The added sentence or two states what the chunk is about and where it sits, so an isolated passage no longer loses the context that made it meaningful. Both embedding and keyword indexes are built over the enriched text.
Conversation Summarization: Conversation summarization compresses earlier turns of a dialogue into a shorter running summary so a session can continue past the limits of what fits in a single prompt. The summary replaces the omitted turns, usually while the most recent messages are kept verbatim. Every summarization pass discards detail permanently.
Corpus: A corpus is the complete body of documents a retrieval system searches over. It defines the boundary of what can be found: nothing outside it is retrievable, however capable the model. Corpus composition, freshness, coverage, and duplication shape retrieval quality more than most tuning decisions applied downstream.
Cosine Similarity: Cosine similarity measures the angle between two vectors, producing a value from negative one to one where one means the vectors point in the same direction. It ignores vector length and compares direction only, which is why it is the standard way to compare text embeddings whose magnitude carries little meaning.
Dense Retrieval: Dense retrieval finds relevant text by comparing embeddings, so a query matches passages whose meaning is close even when no words overlap. Both query and documents are converted into fixed length vectors by a neural model, and similarity is computed in that shared space. It is the retrieval style that most vector database workflows are built around.
Document Ingestion: Document ingestion is the pipeline that takes source files and records, extracts their text and metadata, splits them into passages, generates embeddings, and writes everything into a searchable index. It is the process by which raw material becomes retrievable, and it runs repeatedly as sources are added, changed, or removed.
Embedding: An embedding is a list of numbers that represents a piece of content, such as a sentence, image, or record, in a way that places related items close together in a shared coordinate space. A model produces the vector, and the distance between two vectors approximates how similar their meanings are. Embeddings make similarity computable.
Embedding Dimensionality: Embedding dimensionality is the number of values in each vector produced by an embedding model, commonly a few hundred to a few thousand. It is fixed by the model, and every vector in one collection must share it. Dimensionality drives storage size, comparison cost, and, up to a point, how much meaning a vector can carry.
Entity Resolution: Entity resolution is the process of determining that different records or mentions refer to the same real world thing, such as one customer appearing under three spellings across systems. It merges or links those references into a single identity so that facts about the entity accumulate in one place instead of fragmenting.
Episodic Memory: Episodic memory is the record of specific past events an AI system experienced, such as a particular conversation, a task attempt and its outcome, or a tool call and its result. Each entry is tied to a time and a situation, which lets a system recall what happened on a given occasion rather than only what is generally true.
Fact Extraction: Fact extraction is the process of pulling structured statements out of unstructured text, typically as subject, relation, object triples with a source reference. It converts prose into records that can be filtered, aggregated, updated, and traversed. It underpins knowledge graph construction and most durable memory systems that store what was learned rather than what was said.
Faithfulness: Faithfulness measures whether every claim in a generated answer is supported by the retrieved passages given to the model. It asks only about consistency with the supplied evidence, not about real-world truth, so an answer faithfully repeating an incorrect source still scores well. It is the standard way to detect unsupported additions in retrieval augmented systems.
Forgetting: Forgetting is the deliberate removal or downweighting of stored memories so a system does not carry every past detail forever. Mechanisms include hard deletion on request, time-based expiry, relevance decay that lowers a record's retrieval weight as it ages, and supersession when a newer fact contradicts an older one.
Graph RAG: Graph RAG is retrieval augmented generation that retrieves over a knowledge graph built from the source documents, rather than over independent text chunks alone. Entities and their relationships are extracted during ingestion, and queries traverse those connections to gather evidence spread across many documents. It targets questions that no single passage answers.
Grounding: Grounding is the practice of tying a model's output to verifiable source material rather than letting it answer from its parameters alone. A grounded system retrieves evidence, instructs the model to answer only from it, and expects the answer to state when the evidence is insufficient. The goal is answers that can be checked against a source.
HNSW: HNSW, short for Hierarchical Navigable Small World, is a graph based algorithm for approximate nearest neighbor search. It stores vectors as nodes in a layered proximity graph and answers a query by walking from a coarse top layer down to a dense bottom layer, moving toward closer neighbors at each step. It is the default index in many vector databases.
Hybrid Search: Hybrid search combines keyword matching with vector based semantic matching and merges the two result lists into one ranking. Keyword scoring catches exact terms, identifiers, and rare names, while embeddings catch paraphrase and intent. The blended result is usually more reliable than either method alone, particularly on technical corpora full of codes and product names.
Indexing: Indexing is the process of organizing content into a structure that makes search fast, whether an inverted index mapping terms to documents or an approximate nearest neighbor index over embeddings. Without an index, every query would have to scan the entire collection, so the index is what makes retrieval practical at scale.
Keyword Search: Keyword search retrieves documents that literally contain the terms in a query, ranking them by scoring functions that weigh term frequency and rarity. It is the oldest form of text retrieval and still the most predictable, because a user can see exactly why a result matched. Modern retrieval stacks keep it alongside embedding based search rather than replacing it.
Knowledge Base: A knowledge base is a curated collection of documents and structured facts assembled so that a system or a person can look up answers. In AI applications it usually means the indexed corpus a retrieval system searches, covering policies, product documentation, past tickets, and reference material. Its scope, freshness, and accuracy set the ceiling on answer quality.
Knowledge Cutoff: A knowledge cutoff is the date after which a language model's training data ends, so events, releases, and changes occurring later are absent from its parameters. The model may still answer questions about that period, confidently and incorrectly, unless the application supplies current information or the model is instructed to acknowledge the limit.
Knowledge Graph: A knowledge graph stores information as entities connected by typed relationships, such as a person working at a company that acquired another company. Unlike a document index, it makes connections explicit and queryable, which supports multi step questions that require following links between facts rather than matching text.
Late Chunking: Late chunking embeds a long document in one pass with a long-context embedding model, then pools the resulting token representations into per-chunk vectors afterward. Because every token was encoded while the whole document was visible, each chunk vector carries context from the rest of the text, unlike conventional chunking where pieces are embedded independently.
Long Term Memory: Long term memory is information an AI system retains across sessions and recalls much later, such as stable user preferences, learned facts, and records of completed work. It lives in a database, document index, or knowledge graph outside the model, and it is retrieved selectively rather than carried in every prompt.
Mean Reciprocal Rank: Mean reciprocal rank is a retrieval metric that scores each query by one divided by the position of its first relevant result, then averages across all queries. A first-place hit scores 1.0, second place 0.5, third 0.33. It rewards putting a correct result at the very top and ignores everything after the first hit.
Memory Consolidation: Memory consolidation is the background process of turning accumulated raw interaction records into a smaller, more durable store: merging duplicates, summarizing sessions, promoting recurring details into stable facts, and discarding transient noise. It borrows its name from the biological process by which experiences are stabilized into long-term memory.
Metadata Filtering: Metadata filtering restricts a search to records whose stored attributes satisfy given conditions, such as tenant, language, document type, author, or date range. The filter is applied alongside similarity scoring rather than after the fact, so results are both relevant and permitted. It is the mechanism that makes shared vector collections safe for multiple tenants.
Multi-Query Retrieval: Multi-query retrieval generates several variations of a single user question, runs a search for each, then merges the result sets into one ranked list. The variations differ in phrasing, specificity, or angle, so a document missed by one formulation can still be found by another. It trades extra retrieval cost for higher recall.
Ontology: An ontology is a formal specification of the entity types, relationship types, and constraints that a knowledge store is allowed to contain. It defines what a Person, Order, or Incident is, which relations may connect them, and which properties each requires. Without one, a knowledge graph drifts into inconsistent labels that queries cannot rely on.
Prompt Caching: Prompt caching stores the processed form of a repeated prompt prefix so that subsequent requests reusing that prefix skip part of the computation. Because system instructions and retrieved reference material often stay identical across many calls, caching them reduces latency and cost for the unchanged portion while the varying tail is processed normally.
Query Expansion: Query expansion adds extra terms to a search query in order to retrieve documents that express the same idea in different words. The additions can come from synonym lists, from terms found in top ranked initial results, or from a language model asked to generate related vocabulary. It raises recall at some risk to precision.
Query Rewriting: Query rewriting transforms a user's raw input into a better search query before retrieval runs. Typical rewrites resolve pronouns using conversation history, make an implied subject explicit, strip conversational filler, or split a compound question into parts. It exists because what a person types is often a poor query even when their intent is clear.
Recall and Precision: Recall and precision are the two complementary measures of retrieval quality. Recall is the share of all relevant items that a system actually returned, while precision is the share of returned items that were relevant. Improving one often degrades the other, so retrieval systems are tuned toward a target balance rather than a single number.
Reranking: Reranking is a second scoring pass that reorders an initial list of retrieved candidates using a more accurate and more expensive model. A fast retriever fetches perhaps fifty candidates, and the reranker examines each one against the query to produce a better ordering, from which only the top few are kept for reading.
Retrieval Augmented Generation: Retrieval augmented generation is a technique that improves language model output by fetching relevant documents from an external store at query time and placing them in the model's prompt before it answers. The model composes its response from that supplied evidence rather than from its parameters alone, which allows answers to reflect private or recently updated information.
Retrieval Evaluation: Retrieval evaluation measures how well a search system finds the documents needed to answer a set of test queries. It requires a labeled set pairing queries with known relevant passages, and it scores the retriever separately from the model that writes the final answer. Without it, pipeline changes are guesses.
Retrieval Pipeline: A retrieval pipeline is the ordered sequence of steps that turns a user question into the passages a model reads, typically query processing, retrieval, merging, filtering, reranking, and context assembly. Treating it as a pipeline makes each stage measurable and replaceable, which is how retrieval quality is diagnosed and improved.
Semantic Memory: Semantic memory is an AI system's store of general facts and concepts detached from the occasion on which they were learned, such as a customer's billing cycle or a company's approval threshold. It answers what is true rather than what happened, and it is typically held as structured statements, graph edges, or indexed documents.
Semantic Search: Semantic search retrieves results by meaning rather than by literal word overlap. Queries and documents are converted into embeddings, and the system returns the items whose vectors sit closest to the query vector. This lets a search for ending my plan surface a document titled cancellation policy, even when the two share no terms.
Short Term Memory: Short term memory is the recent context an AI system keeps available within a conversation or session, typically the last several exchanges plus any state built during the current task. It lives in the prompt or in a session store, and it is discarded or summarized when the session ends.
Similarity Score: A similarity score is the number a retrieval system assigns to a candidate result indicating how closely it matches the query, used to rank results and sometimes to filter weak ones. Scores are relative to the scoring method and the corpus, so a value that looks high in one system may be unremarkable in another.
Sparse Retrieval: Sparse retrieval scores documents using term based representations in which most entries are zero, matching on the words a query and document actually share. Classical keyword ranking functions are the best known form, and learned sparse models extend the idea by predicting term weights with a neural network. It complements embedding based search rather than competing with it.
Text Extraction: Text extraction is the step that recovers readable text and structure from source formats such as PDFs, word processor files, spreadsheets, slides, web pages, images, and audio. Its output quality sets an upper bound on everything downstream, since a passage never extracted correctly cannot be chunked, embedded, or retrieved correctly.
User Profile Memory: User profile memory is a persistent, structured record of durable facts about an individual user, such as their role, preferences, working context, and constraints. Unlike conversation history it is intentionally small, curated, and injected into most sessions. It exists so an assistant does not have to relearn stable details in every new conversation.
Vector Database: A vector database is a data store built to hold high dimensional numeric vectors and to find the ones most similar to a query vector quickly. It indexes embeddings produced by machine learning models and supports nearest neighbor search, usually with metadata filters. Such systems underpin semantic search and retrieval for language model applications.
Vector Index: A vector index is the data structure that makes similarity search over stored embeddings fast, by organizing vectors so a query can skip most of the collection. Without one, a search must compare the query against every vector. The index type chosen sets the achievable balance between query speed, memory footprint, accuracy, and update cost.
Working Memory: Working memory is the information an AI system actively holds while performing a task, including the current goal, intermediate results, tool outputs, and constraints being tracked. It is scoped to the task rather than to the session, and it is assembled fresh for each model call from the pieces the next step requires.

Protocols and Tools

Agent Card: An agent card is a machine readable metadata document that describes an AI agent to other agents, listing its name, address, capabilities, supported input and output formats, and how to authenticate with it. The term comes from the A2A protocol, where cards are published at a well known path on the agent's own domain so that clients can discover them automatically.
Agent to Agent Protocol: An agent to agent protocol is a standard that lets independent AI agents, built by different teams on different frameworks, discover each other and exchange tasks over a network. The best known example is A2A, originally published by Google and later donated to the Linux Foundation. Agents describe themselves in a published metadata document and communicate without exposing their internal tools or reasoning.
API: An API, or application programming interface, is a defined way for one piece of software to request something from another. It specifies the available operations, the inputs each expects, the outputs it returns, and the errors it can raise, so that two systems can work together without either needing to know how the other is built.
API Key: An API key is a secret string that a client sends with each request to identify itself to a service. It is the simplest form of API credential, easy to issue and to use, but it carries no user identity, usually does not expire on its own, and grants whatever it is permitted to do to anyone who holds it.
API Versioning: API versioning is the practice of labeling an interface so that changes can be introduced without breaking existing clients. The version may appear in the URL path, in a request header, or in a dated release identifier. Its purpose is to let a provider evolve while callers written against an older contract keep working unchanged.
Batch Request: A batch request bundles several operations into one API call so they are transmitted and processed together. Bulk endpoints accept an array of records for a single operation, while generic batching accepts a list of independent sub-requests. Batching reduces per call overhead and round trips, at the cost of more complicated partial failure handling.
Bearer Token: A bearer token is a credential whose mere possession grants access, presented in an HTTP Authorization header with the Bearer scheme. The server validates the token and needs no further proof of identity, which is what the term bearer means. Bearer tokens are defined for OAuth 2.0 in RFC 6750 and are usually short lived.
Browser Automation: Browser automation is the programmatic control of a web browser, driving navigation, clicks, typing, and data extraction through code. It is used for testing, for repetitive web tasks, and increasingly to let AI agents operate websites that offer no API. Modern tools control real browser engines, so pages behave the same way they do for an ordinary visitor.
Callback URL: A callback URL is an address that one system gives another so the second system can direct a browser or a request back to it once something finishes. It appears in authorization flows as the redirect target after a user approves access, and in asynchronous APIs as the endpoint that receives a result when a long running job completes.
Capability Discovery: Capability discovery is the exchange at the start of a connection in which each side declares what optional features it supports, so both can agree on a working subset. It lets a protocol evolve without breaking older peers, because a participant simply does not use a feature the other side did not advertise. The Model Context Protocol performs this during initialization.
Computer Use: Computer use is a capability in which an AI model operates a graphical computer interface directly, viewing the screen as images and issuing mouse and keyboard actions. It lets a model work with any application, including software that exposes no API at all, at the cost of being slower and less reliable than calling a programmatic interface.
Connector: A connector is a prebuilt, reusable component that links a platform to one specific external service, packaging the authentication, endpoints, and data mapping that an integration to that service requires. Users typically enable one and sign in rather than writing code. The term is vendor specific, and the depth of what a connector actually does varies widely between products.
Cursor: A cursor is an opaque marker returned with a page of results that tells the server where the next page should begin. Instead of counting a numeric offset, the client passes the cursor back and the server resumes reading immediately after the encoded position. The same idea appears as a continuation token in streaming and event APIs.
Deprecation Policy: A deprecation policy is a provider's published commitment about how an API feature is retired: how much notice is given, how the warning is communicated, and how long the feature keeps working after being marked obsolete. Deprecated means discouraged and scheduled for removal, not yet removed. Clear policies let integrators plan migrations instead of reacting to outages.
Elicitation: Elicitation is a Model Context Protocol feature that lets a server ask the connected client to collect additional information from the user during an operation. The server sends a request describing what it needs, the client presents it and returns the user's answer or a decline. It exists so servers can pause for missing input rather than failing or guessing.
Function Calling: Function calling is a capability in which a language model, given descriptions of available functions, responds with a structured request naming one of them and supplying arguments, rather than replying in prose. The application receives that request, executes the function itself, and returns the result to the model. The model never runs any code.
GraphQL: GraphQL is a query language and server-side runtime for APIs in which the client states exactly which fields it wants and receives a JSON response shaped to that request. It was released publicly by Facebook in 2015 and is now stewarded by the GraphQL Foundation. A single endpoint typically serves queries, mutations, and subscriptions against a strongly typed schema.
gRPC: gRPC is an open source remote procedure call framework originally developed at Google and now hosted by the Cloud Native Computing Foundation. Service methods and message types are declared in a Protocol Buffers interface file, compiled into client and server code, and transported over HTTP/2 with binary serialization. It supports unary calls and streaming in either or both directions.
Headless Browser: A headless browser is a full browser engine running without a visible window, controlled entirely by code. It loads pages, executes JavaScript, applies styles, and builds the same document as a normal browser, but renders offscreen. This makes it the standard way to run automated tests and page fetching on servers, where no display exists at all.
HMAC Signature: An HMAC signature is a keyed hash computed over a request payload with a secret shared by sender and receiver, sent alongside the request so the receiver can recompute it and confirm the payload is authentic and unmodified. HMAC is defined in RFC 2104. It is the standard way providers let receivers verify that a webhook genuinely came from them.
Idempotency: An operation is idempotent when performing it more than once has the same effect as performing it once. This property matters whenever a request might be delivered twice, because a network failure often leaves the caller unsure whether the first attempt succeeded. Idempotency is what makes a safe retry possible without creating duplicates.
Integration: An integration is a working connection between two systems that lets data or actions flow between them. It is the built result rather than the interface that made it possible, and it typically includes authentication, data mapping, error handling, and some way of keeping the two sides in step over time.
JSON Schema: JSON Schema is a specification for describing the structure of JSON data, stating which fields exist, what types they hold, which are required, and what values are allowed. It is used both to validate documents automatically and to document them. In AI systems it is the usual way to define tool parameters and to constrain model output.
JSON-RPC: JSON-RPC is a lightweight remote procedure call protocol in which requests and responses are JSON objects. A request names a method, supplies parameters, and usually carries an identifier that the matching response echoes. Version 2.0 is transport agnostic, running over HTTP, WebSocket, standard input and output, or any other message channel.
llms.txt: llms.txt is a proposed convention in which a website publishes a plain markdown file at the path /llms.txt containing a short, curated description of the site and links to its most useful pages. The intent is to give language models a clean overview instead of leaving them to parse navigation and layout. It is a community proposal rather than an adopted standard.
Long Polling: Long polling is a technique in which a client sends an HTTP request and the server intentionally holds it open until new data is available or a timeout expires. The client then immediately issues another request. It approximates server push using only ordinary request and response semantics, and predates widely available streaming transports.
MCP Client: An MCP client is the component inside an AI application that maintains a connection to a single MCP server and relays messages between that server and the application. The application that creates one or more clients is usually called the host. Clients handle version and capability negotiation, request routing, and returning tool results to the model.
MCP Server: An MCP server is a program that exposes tools, data resources, or prompt templates to AI applications using the Model Context Protocol. It wraps an underlying system such as a database, file store, or web service, describes what it can do in machine readable form, and executes the requests that a connected client sends to it.
Model Context Protocol: Model Context Protocol is an open standard that defines how AI applications connect to external tools and data sources. It specifies a client and server architecture in which servers expose capabilities such as callable tools, readable resources, and reusable prompts, and clients consume them over a common message format. It was originally published by Anthropic and is developed openly as a public specification.
Mutual TLS: Mutual TLS is a configuration of the TLS protocol in which both parties present certificates during the handshake, so the server authenticates the client as well as the client authenticating the server. Ordinary HTTPS authenticates only the server. Mutual TLS is widely used between internal services and for high assurance API access.
OAuth: OAuth is an open standard that lets an application act on a user's behalf inside another service without ever seeing that user's password. The user approves a limited scope of access at the service itself, and the application receives a token that grants only what was approved and can be revoked at any time. OAuth 2.0 is the version in general use.
OpenAPI Specification: The OpenAPI Specification is an open standard for describing HTTP APIs in a machine readable document, written in YAML or JSON. It defines endpoints, parameters, request and response schemas, authentication methods, and examples. Originally named Swagger, it was donated to the OpenAPI Initiative under the Linux Foundation and is now the most widely used API description format.
Pagination: Pagination is the practice of returning a large result set in smaller sequential pages rather than all at once. The response carries one page of items plus a way to request the next, such as a page number, an offset, or an opaque cursor. It bounds memory, response size, and query cost for both sides.
Rate Limiting: Rate limiting is a control that caps how many requests a client may make to a service within a period of time. It protects capacity, contains cost, and prevents one caller from degrading service for everyone else. Callers that exceed the limit receive a rejection, conventionally an HTTP 429 status, often accompanied by guidance on when to retry.
Refresh Token: A refresh token is a long lived credential issued alongside a short lived access token, used solely to obtain a new access token when the old one expires. It is never sent to the resource API. Keeping it separate lets access tokens expire quickly without forcing the user to sign in again each time.
Replay Attack Protection: Replay attack protection is the set of measures that stop a valid captured request from being accepted a second time. A signature proves a message is authentic but says nothing about whether it is fresh, so protocols add timestamps, single use values, or sequence tracking to ensure each request is honored only once.
Resource (MCP): A resource in the Model Context Protocol is a piece of readable context that a server exposes to a client, identified by a URI and returned on request. Resources are one of the protocol's primitives alongside tools and prompts. Unlike a tool, reading a resource is intended to supply information rather than to perform an action with side effects.
REST API: A REST API is a web interface organized around resources identified by URLs, manipulated with standard HTTP methods, and exchanged in a common format such as JSON. REST, short for representational state transfer, is an architectural style described in 2000 rather than a protocol, and most interfaces called REST follow only part of it.
robots.txt for AI Agents: robots.txt is a text file at a website's root that tells automated clients which paths they may request, standardized as the Robots Exclusion Protocol. Applied to AI, site owners add rules naming the crawlers operated by AI companies in order to allow or refuse them. Compliance is voluntary, so the file expresses a request rather than an enforced control.
Sandbox: A sandbox is an isolated environment in which code runs with restricted access to the surrounding system, so that whatever happens inside cannot damage or reach what lies outside. Isolation typically covers the file system, the network, other processes, and resource consumption. It is the standard containment measure for running untrusted code or agent generated commands.
Scope: A scope is a named permission requested during an authorization flow that bounds what an issued token may do. Scopes appear as space separated strings in the authorization request, are shown to the user on the consent screen, and are enforced by the resource server on every call. They express the principle of least privilege in access delegation.
SDK: An SDK, or software development kit, is a package that makes a service usable from a specific programming language, wrapping its network interface in native functions, types, and error classes. A good one handles authentication, retries, pagination, and streaming, so that developers write ordinary code instead of assembling HTTP requests by hand.
Server-Sent Events: Server-Sent Events is a web standard for streaming a one way sequence of text events from a server to a client over a single long lived HTTP response. The response uses the text/event-stream media type and a simple line based format, and browsers consume it through the EventSource interface with automatic reconnection built in.
Service Account: A service account is an identity belonging to an application or automated process rather than a person, used to authenticate machine to machine calls. It holds its own credentials and permissions, and it authenticates without an interactive login or consent screen. Cloud platforms, databases, and internal APIs all use service accounts to attribute and restrict automated access.
Stdio Transport: Stdio transport is a communication mechanism in which two programs exchange messages over standard input and standard output rather than a network socket. The host launches the other program as a child process and writes requests to its standard input, reading replies from its standard output. It is one of the transports defined for the Model Context Protocol.
Streaming Response: A streaming response is an API reply delivered as a sequence of partial chunks while it is still being produced, rather than as one complete payload sent at the end. The client processes each chunk on arrival, which lowers perceived latency. Language model APIs commonly stream generated text token by token, alongside events describing tool calls and completion.
Structured Output: Structured output is model output constrained to a predefined machine readable format, most often JSON matching a supplied schema, instead of free form prose. Some providers enforce this during generation so the result is guaranteed to parse and conform, while weaker approaches merely request the format in the prompt and validate afterwards.
Terminal Execution: Terminal execution is giving an AI agent the ability to run shell commands on a machine and read their output. It is among the most capable tools an agent can hold, since almost any software task can be expressed as a command, and among the most dangerous, because the same interface can delete data or send secrets elsewhere.
Tool Calling: Tool calling is the pattern in which a language model is given a set of external capabilities, chooses one, has the surrounding application run it, reads the result, and repeats until the task is finished. It is largely synonymous with function calling, with different vendors preferring different names for the same underlying mechanism.
Tool Schema: A tool schema is the machine readable description of a single capability offered to a language model, giving the tool a name, a natural language description of when to use it, and a formal definition of its parameters. Models rely on this description alone when deciding whether and how to call the tool, so its wording directly shapes behavior.
Web Scraping: Web scraping is the automated extraction of data from web pages, turning content meant for human reading into structured records. A scraper fetches pages, parses the markup, selects the relevant elements, and stores the result. It is a long standing practice whose legality and acceptability depend heavily on what is collected, how it is collected, and what is done with it.
Webhook: A webhook is an HTTP request that one system sends to a URL you supply whenever a chosen event happens, so you learn about it immediately instead of repeatedly asking. It inverts the usual direction of an API call, since the provider becomes the caller and your endpoint becomes the server. Whether it is called inbound or outbound depends on which side you stand on.
WebSocket: WebSocket is a standardized protocol that upgrades an HTTP connection into a persistent, full duplex channel over a single TCP connection. Once the handshake completes, either side may send message frames at any time without waiting to be asked. It is specified in RFC 6455 and is supported natively by browsers through the WebSocket JavaScript interface.

Safety and Governance

AI Governance: AI governance is the set of policies, roles, processes, and records an organization uses to decide which AI systems it builds or buys, under what conditions they operate, who is accountable for them, and how they are monitored after deployment. It converts abstract principles into decisions that can be evidenced.
AI Guardrails: AI guardrails are controls placed around a language model that constrain what reaches it and what it is permitted to produce or do. They run outside the model itself, using classifiers, rules, allow lists, schema validation, and policy checks at the input, retrieval, output, and tool layers. Guardrails complement training-time safety rather than replacing it.
AI Incident Response: AI incident response is the process for detecting, containing, investigating and remediating harmful failures of an AI system, such as harmful output reaching users, unauthorized actions taken by an agent, or exposure of data through model behavior. It adapts established security incident practice to failures that are probabilistic, hard to reproduce and often invisible in conventional error monitoring.
Alignment: Alignment is the research problem and engineering practice of making an AI system pursue the goals its developers and users actually intend, including unstated norms and constraints. It covers both specifying the right objective and ensuring the trained system genuinely internalizes it rather than learning a proxy that scores well during training.
Anonymization: Anonymization is the process of transforming data so that individuals can no longer be identified from it, by anyone, using any means reasonably likely to be used. Under the GDPR truly anonymized data falls outside data protection law entirely, which is why the standard is strict and why many datasets described as anonymized do not actually meet it.
Approval Gateway: An approval gateway is a control that pauses an automated action and requires an authorized person to confirm it before execution. Actions are classified by consequence, so routine reads proceed automatically while irreversible, costly, external, or cross-boundary operations wait for a decision. The gateway records who approved what, when, and on which exact parameters.
Audit Trail: An audit trail is a durable, append-only record of significant events in a system, capturing who or what acted, on which resource, at what time, with what parameters, and with what result. Unlike debug logs, it is retained on a defined schedule, protected from modification, and designed to be read by investigators, auditors, and regulators.
Bias: Bias in AI refers to systematic differences in a system's behavior or accuracy across groups, contexts, or inputs, particularly where those differences are unjustified and cause harm. It originates in training data, labeling choices, objective design, and deployment context rather than in any single component, and it is measured against a chosen fairness definition.
CCPA: The CCPA is California's consumer privacy law, significantly amended by a later ballot measure, granting residents rights to know, delete and correct personal information and to opt out of its sale or sharing. It applies to for profit businesses meeting statutory thresholds that handle California residents' personal information, regardless of where the business itself is located.
Confused Deputy Problem: The confused deputy problem is a security flaw in which a program holding legitimate privileges is tricked by a less privileged party into misusing those privileges on that party's behalf. The deputy is authorized and behaves as designed, but it acts on a request without carrying the requester's authority. The pattern was named in the computer security literature in 1988.
Content Moderation: Content moderation is the classification and handling of text, images, or other media against a defined policy covering categories such as violence, sexual content, harassment, self-harm, and illegal activity. In AI systems it is applied to user input, to generated output, or to both, with actions ranging from blocking to rewriting to escalating for human review.
Content Provenance: Content provenance is the practice of attaching verifiable records of origin and edit history to digital media, so a viewer can check where an asset came from and how it was modified. Open specifications, most prominently the work of the Coalition for Content Provenance and Authenticity, define cryptographically signed manifests that travel with a file or are recoverable from it.
Data Leakage Prevention: Data leakage prevention is the practice of stopping sensitive information from leaving a controlled environment through unintended channels. In AI systems the channels include prompts sent to external providers, model outputs delivered to the wrong recipient, over-permissioned retrieval, logs and telemetry, and training on data that was never cleared for that purpose.
Data Minimization: Data minimization is the principle that a system should collect and keep only the personal data genuinely needed for a stated purpose, and nothing beyond it. It appears as a legal requirement in privacy regimes such as the GDPR and as an engineering practice in security design, where a smaller data footprint limits both regulatory exposure and the damage any single breach can cause.
Data Processing Agreement: A data processing agreement is a contract between a controller and a processor that governs how personal data may be handled on the controller's behalf. Article 28 of the General Data Protection Regulation requires such a contract and specifies terms it must contain, including the subject matter, duration, nature and purpose of processing, and the categories of data involved.
Data Residency: Data residency refers to the geographic location where data is stored and processed. It is distinct from data sovereignty, which concerns which country's laws govern the data, and from data localization, which is a legal requirement to keep certain data within national borders. Buyers frequently ask about residency because location shapes both legal exposure and access risk.
Data Subject Access Request: A data subject access request is a formal request from an individual asking an organization to confirm whether it processes their personal data and to provide a copy along with details of that processing. Recognized under the GDPR and comparable laws, it carries statutory response deadlines and is one of the most common ways privacy compliance is tested in practice.
Deepfake: A deepfake is synthetic audio, image or video that convincingly depicts a real person saying or doing something they did not. The term covers a spectrum from consensual entertainment and dubbing to non consensual intimate imagery, political disinformation and fraud, and the harms and legal treatment differ sharply across that spectrum.
Differential Privacy: Differential privacy is a mathematical definition of privacy guaranteeing that the output of an analysis is nearly unchanged whether or not any single individual's record was included. It is achieved by adding calibrated random noise to computations, and the strength of the guarantee is expressed by a privacy budget parameter, conventionally written as epsilon, where smaller values mean stronger privacy.
Egress Control: Egress control is the restriction of outbound network connections from a system to an explicitly approved set of destinations. In AI deployments it is a primary defense against data exfiltration, because an agent that has been manipulated through injected instructions still cannot send data anywhere the network policy does not permit.
Encryption At Rest: Encryption at rest is the practice of storing data in encrypted form on disks, databases, object storage and backups so that the raw media cannot be read without the corresponding keys. It is a baseline control in nearly every security framework, and it defends primarily against theft of storage, misplaced backups and improperly decommissioned hardware.
Encryption In Transit: Encryption in transit is the protection of data while it moves across a network, normally using Transport Layer Security, so that traffic cannot be read or silently altered by anyone positioned between the endpoints. It is a baseline expectation for public internet traffic and, in modern architectures, increasingly for internal service to service traffic as well.
EU AI Act: The EU AI Act is the European Union's regulation on artificial intelligence, Regulation (EU) 2024/1689, which entered into force in August 2024. It classifies AI systems by risk and attaches obligations accordingly, from outright prohibition to transparency duties. It applies to providers and deployers placing systems on the European Union market regardless of where they are established.
Explainability: Explainability is the degree to which the reasons for an AI system's output can be presented in terms a person can understand and check. It matters where decisions affect people, where errors must be diagnosed, and where regulation or contract requires a rationale. For large neural networks it remains only partially achievable.
GDPR: The General Data Protection Regulation is European Union law governing the processing of personal data, applicable since May 2018. It requires a lawful basis for processing, sets principles such as purpose limitation and data minimization, grants individuals enforceable rights over their data, and applies to organizations outside Europe that target or monitor people within it.
Hallucination: A hallucination is output from a language model that is fluent and confident but factually wrong or unsupported by any source. It arises because such models predict likely continuations of text rather than retrieving verified facts, so plausibility and truth can diverge. Common forms include invented citations, fabricated figures, and imagined product features or API methods.
HIPAA: HIPAA is a United States federal law whose privacy, security and breach notification rules govern how protected health information is used and disclosed. It applies to covered entities such as health plans and most healthcare providers, and to business associates that handle protected health information on their behalf under a written agreement.
Indirect Prompt Injection: Indirect prompt injection is a variant in which the malicious text is planted in content the model later retrieves, such as a web page, document, email, calendar invite, or code comment, rather than typed by the user. The victim triggers the attack simply by asking the assistant to read or summarize that content. It was described in published research in 2023.
Input Safety: Input safety refers to checks applied to a message or document before it reaches the model. Typical checks cover injection patterns, prohibited request categories, personal data that should not enter context, oversized or malformed payloads, and rate or quota limits. Blocking at this stage prevents cost, exposure, and the generation of unsafe content in the first place.
ISO/IEC 27001: ISO/IEC 27001 is an international standard specifying requirements for an information security management system, a documented framework for identifying security risks and applying controls to treat them. Organizations can be certified against it by an accredited body following an audit, and certification is commonly requested in enterprise and international procurement.
Jailbreak: A jailbreak is a prompt or conversation designed to make a model produce content its safety training and usage policies are meant to refuse. Techniques generally work by reframing the request, for example as fiction, translation, research, or a hypothetical, so the harmful intent is less apparent to the model's learned refusal behavior.
Key Management: Key management is the set of practices governing how cryptographic keys are generated, stored, distributed, rotated, revoked and destroyed. Because encryption transfers the security of data onto the security of its keys, key management is the control that determines whether encryption provides real protection or only satisfies a checklist.
Least Privilege: Least privilege is the security principle that every component, credential, and process should hold only the permissions required for its specific task, and only for as long as the task runs. Articulated for computer systems in the 1970s, it limits the damage from any single compromise, bug, or manipulation, since a bounded identity can only cause bounded harm.
Model Drift: Model drift is the degradation of an AI system's performance over time as production conditions diverge from the conditions it was built for. It covers data drift, where input distributions shift, concept drift, where the relationship between input and correct answer changes, and version drift, where an underlying model or prompt is updated beneath a working system.
Model Evaluation: Model evaluation is the systematic measurement of a model or AI system against defined criteria using repeatable test sets. It spans capability benchmarks, task-specific accuracy on representative data, safety and refusal behavior, robustness to adversarial input, and regression testing after any change to a prompt, model, or retrieval configuration.
Model Provider Data Policy: A model provider data policy is the published set of terms describing how an AI vendor handles the content sent to its models, covering retention, training use, human review, subprocessors, geographic processing and deletion. It is the document a deploying organization must read before routing customer data through a model, because these terms vary widely and change over time.
NIST AI Risk Management Framework: The NIST AI Risk Management Framework is a voluntary framework published by the United States National Institute of Standards and Technology for identifying, measuring and managing risks from artificial intelligence systems. It is organized around four functions, Govern, Map, Measure and Manage, and is widely used as a common vocabulary for AI risk work rather than as a certifiable standard.
Output Safety: Output safety refers to checks applied to a model's response after generation and before it is displayed, sent, or executed. Typical checks cover prohibited content, leaked system instructions or credentials, personal data, unsupported factual claims, schema conformance, and unsafe tool arguments. It is the last automated point at which a bad response can be stopped.
Over-Refusal: Over-refusal is the failure mode in which an AI system declines a harmless request because it superficially resembles a harmful one. It is the mirror image of unsafe compliance, and because most safety interventions trade one against the other, systems are normally measured on both rates rather than on refusals avoided alone.
PII Detection: PII detection is the automated identification of personally identifiable information inside text, files, or database fields. Techniques combine pattern matching with checksums for structured identifiers, named entity recognition for names and addresses, and contextual classifiers for ambiguous cases. Detection is a prerequisite for redaction, access control, retention enforcement, and breach assessment.
PII Redaction: PII redaction is the removal or replacement of personal data in text before it is stored, logged, or sent onward. Methods include masking with placeholders, replacing values with reversible tokens, generalizing a value to a coarser range, and substituting realistic synthetic values. The method chosen determines whether the original can ever be recovered.
Prompt Injection: Prompt injection is an attack in which text supplied by an untrusted party is interpreted by a language model as instructions rather than as data. Because a model sees one undifferentiated context window, attacker text can override developer intent and trigger disclosure of hidden instructions or unauthorized tool actions. It is widely considered an unsolved class of vulnerability.
Pseudonymization: Pseudonymization is the processing of personal data so that it can no longer be attributed to a specific person without additional information kept separately and protected. The GDPR defines it explicitly and treats it as a security and risk reduction measure, but pseudonymized data remains personal data and stays fully within the scope of data protection law.
Purpose Limitation: Purpose limitation is the principle that personal data collected for one specified purpose may not be reused for an unrelated purpose without a fresh legal basis. It is a core requirement of the GDPR and similar frameworks, and it is the rule most often tested when data gathered to deliver a service is later proposed as training material or analytics input.
Red Teaming: Red teaming is structured adversarial testing in which people deliberately try to make a system behave harmfully, leak data, or bypass its controls. Unlike a fixed evaluation suite, it is open-ended and creative, aiming to discover failure modes nobody anticipated. Findings are then converted into permanent test cases so the same weakness cannot silently return.
Responsible Disclosure: Responsible disclosure is the practice by which a person who discovers a security vulnerability reports it privately to the affected organization and allows time for a fix before publishing details. Also called coordinated vulnerability disclosure, it depends on a published reporting channel, a stated timeline, and assurance that good faith researchers will not face legal action.
Right To Erasure: The right to erasure is a data protection right allowing an individual to request deletion of personal data an organization holds about them. Established in Article 17 of the GDPR and echoed in other regimes, it is qualified rather than absolute: several grounds must apply, and exemptions exist for legal obligations, defense of legal claims and certain public interest purposes.
Role Based Access Control: Role based access control is an authorization model in which permissions are attached to named roles, and users receive access by being assigned those roles rather than by receiving permissions individually. Changing what a role can do changes access for everyone holding it. The model is generic and standardized, independent of any particular vendor or product.
Safety Evaluation: Safety evaluation is the systematic testing of an AI system's behavior against defined harm categories, measuring how often it produces disallowed content, complies with manipulation attempts, or takes unsafe actions. It complements capability evaluation, which measures what a system can do, and it usually combines automated test suites with adversarial human probing.
Sandboxed Execution: Sandboxed execution is running code or tools produced or invoked by an AI system inside a strongly isolated environment with restricted access to the filesystem, network, host resources and other tenants' data. It exists because model generated code should be treated as untrusted input, regardless of whether the model that produced it is considered reliable.
Single Sign-On: Single sign-on is an authentication arrangement in which a user authenticates once with a central identity provider and then reaches multiple independent applications without entering credentials again. The applications trust assertions issued by that provider instead of storing passwords themselves. It is a generic model implemented through open protocols rather than a single product.
SOC 2: SOC 2 is an attestation report produced by an independent accounting firm assessing a service organization's controls against the Trust Services Criteria defined by the American Institute of Certified Public Accountants. Security is always in scope, with availability, processing integrity, confidentiality, and privacy optional. It is a report on controls, not a certification or a legal requirement.
Tenant Isolation: Tenant isolation is the separation of one customer's data, configuration, and workloads from every other customer's inside a shared system. It is enforced across storage, retrieval, caching, background jobs, and logs. Cross-tenant leakage, where one customer sees another's data, is generally treated as the most severe defect class in multi-tenant software.
Tool Poisoning: Tool poisoning is an attack in which the descriptions, schemas, or metadata that tell an AI agent how to use a tool are altered to contain hidden instructions. Because the agent reads these definitions as trusted configuration, malicious text placed there can influence its behavior without ever appearing in a user message. It is a supply chain variant of prompt injection.
Training Opt Out: A training opt out is a setting or contractual term under which a provider agrees not to use a customer's inputs and outputs to train or improve its models. Defaults differ substantially by provider, product tier and region, so whether content is used for training is a question to verify in current terms rather than assume.
Watermarking: Watermarking is the embedding of a detectable signal into AI generated content so that its machine origin can later be identified. For images and audio the signal is imperceptible modification of the media; for text it is usually a statistical bias applied during token selection. Robustness against editing and paraphrasing remains a significant and actively researched limitation.
Zero Data Retention: Zero data retention is a service configuration in which inputs and outputs are processed to fulfill a request and then not stored afterward. It is offered by some AI providers under specific plans or agreements and is frequently required in regulated procurement, though the exact scope of what is and is not retained varies considerably between vendors.
Zero Trust: Zero trust is a security model that removes implicit trust based on network location and requires every request to be authenticated, authorized, and continuously evaluated against policy. Being inside a corporate network confers no privilege by itself. Access decisions consider identity, device state, and context, and grant only the privilege needed for that specific request.

Running in Production

Agent trajectory logging: Agent trajectory logging is the practice of recording the full ordered sequence of steps an autonomous agent took during a run, including the messages it received, the intermediate summaries it produced, the tools it called with their arguments and results, and the final outcome. The stored trajectory lets a run be replayed, audited, and evaluated after the fact.
Alerting: Alerting is the practice of notifying a responsible person or system when monitored signals indicate a condition that requires attention. An alert defines a condition, a severity, a destination, and ideally a documented response. The central design problem is precision: alerts that fire without a required response train recipients to ignore them, which is how genuine incidents get missed.
At-Least-Once Delivery: At-least-once delivery is a messaging guarantee in which every message is delivered to a consumer one or more times, never zero. The system retries until it receives an acknowledgment, which means a message whose acknowledgment is lost will be redelivered. Consumers must therefore tolerate seeing the same message more than once.
Autoscaling: Autoscaling is the automatic adjustment of computing capacity in response to observed load or a schedule. Horizontal autoscaling adds or removes instances, while vertical autoscaling changes the resources allocated to an existing instance. It matches capacity to demand without manual intervention, but reacts only after a signal appears, so it cannot absorb a spike faster than new capacity can start.
Backpressure: Backpressure is the mechanism by which an overloaded component signals upstream producers to slow down or stop sending work. Instead of accepting more than it can process and collapsing, the component pushes resistance back through the pipeline. The result is degraded throughput under load rather than a cascading failure.
Blast Radius: Blast radius is the scope of harm a failure, defect, or malicious action can reach before something stops it. It is described in terms of who and what is affected: how many users or tenants, which data, which downstream systems, and whether the effects can be reversed. Reducing it is a design goal independent of reducing failure likelihood.
Canary Release: A canary release is a deployment strategy that sends a new version to a small share of traffic first, compares its behavior against the existing version, and expands the rollout only if the metrics look healthy. It limits the number of users exposed to a defective release and provides real production signal before full exposure. Its usefulness depends entirely on having metrics good enough to detect the problem.
Circuit Breaker: A circuit breaker is a resilience pattern that stops calls to a failing dependency after errors cross a threshold, returning failures immediately instead of waiting on timeouts. After a cooling period it allows a small number of trial calls, and restores normal traffic if those succeed. The pattern protects a struggling service from load and keeps the caller responsive.
Cold Start Latency: Cold start latency is the extra delay incurred when a request arrives at capacity that is not yet ready to serve, requiring initialization first. The work may include starting a container, loading model weights, establishing connections, or populating caches. It affects the first requests after a scale-up, a deploy, or an idle period.
Compensating Transaction: A compensating transaction is an operation that semantically reverses the effect of a previously committed step, used when a multi-step process fails partway and a true rollback is impossible. Rather than erasing history, it applies a counteracting change: a refund offsets a charge, a cancellation offsets a booking, a correction notice offsets a sent message.
Concurrency: Concurrency is the number of units of work a system has in progress at the same time. It is a control knob rather than an outcome: raising it can increase throughput until a bottleneck is reached, after which it mainly increases queueing and latency. Concurrency limits are usually enforced per tenant, per worker pool, and per external dependency.
Cost Attribution: Cost attribution is the practice of assigning machine costs, such as model tokens, tool calls, and compute, to the entity that caused them: a tenant, a feature, an agent, or an individual run. It turns a single aggregate provider bill into a breakdown that can be acted upon, priced against, or optimized.
Cost per action: Cost per action is the total resource cost attributed to one completed unit of work, such as one answered ticket, one drafted document, or one enriched record. It aggregates model tokens, tool and API calls, storage, retries, and failed attempts. Because a single action often involves many model calls, cost per action is usually far higher than the cost of one call.
Cron: Cron is a time based scheduler originating in Unix, and by extension the expression syntax used to describe recurring schedules. A cron expression uses five or six fields covering minute, hour, day of month, month, day of week, and sometimes seconds. The syntax has become the common vocabulary for recurring schedules well beyond the original program.
Dead Letter Queue: A dead letter queue is a separate holding area for messages that could not be processed successfully after their retry attempts were exhausted. Moving failures aside keeps a poison message from blocking or endlessly recycling through the main queue, while preserving the payload for inspection. Items in a dead letter queue can be examined, fixed, and replayed once the underlying cause is resolved.
Durable Execution: Durable execution is a model in which a long running process survives crashes, deploys, and restarts without losing its place. The engine records the outcome of each completed step, then reconstructs the process state by replaying that history and skipping work already done. It lets code that waits minutes, days, or longer be written as ordinary sequential logic.
Error Budget: An error budget is the amount of unreliability a service is permitted over a period, derived directly from its reliability target. If the target is 99.9 percent of requests succeeding in a month, the budget is the remaining 0.1 percent. Spending within budget is normal; exhausting it triggers an agreed change in how the team operates.
Evaluation Harness: An evaluation harness is the software scaffolding that runs a set of test inputs through an AI system, collects the outputs, scores them against defined criteria, and reports aggregate results. It standardizes how quality is measured so that two runs, two prompts, or two model configurations can be compared on identical terms rather than on impressions.
Exponential backoff: Exponential backoff is a retry timing strategy in which the wait between attempts grows multiplicatively, for example one second, then two, then four. Random jitter is added so that many clients failing at once do not retry in synchronized waves. The approach gives an overloaded dependency time to recover instead of adding load during its worst moment.
Fail Open and Fail Closed: Fail open and fail closed describe the two ways a system can behave when a check or dependency is unavailable. Failing open allows the operation to proceed, favoring availability. Failing closed blocks the operation, favoring safety or security. The correct choice depends on what the failing component protects, and picking the wrong default is a recurring source of both outages and breaches.
Feature Flag: A feature flag is a runtime switch that determines whether a piece of behavior is active, letting teams change what a system does without deploying new code. Flags can be global, or evaluated per user, tenant, or request, which allows a change to be enabled for a subset of traffic and reversed immediately.
Golden Dataset: A golden dataset is a curated collection of inputs paired with agreed-upon correct outputs, used as the reference standard when evaluating an AI system. Its examples are deliberately chosen and reviewed rather than sampled at random, so that the set covers the behaviors a team has decided matter most, including known past failures.
Graceful Degradation: Graceful degradation is the practice of designing a system so that partial failures reduce functionality instead of causing a total outage. Non-essential features are disabled, stale data is served, or simpler fallbacks take over while the core path keeps working. The goal is a smaller and more predictable blast radius when a dependency becomes slow or unavailable.
Human Review Queue: A human review queue is a work list where AI outputs or pending actions wait for a person to approve, reject, or edit them before they take effect or reach a recipient. It converts an autonomous step into a supervised one for cases that are high risk, low confidence, or subject to policy requirements.
Incident: An incident is an unplanned disruption or degradation of a service that requires a coordinated response. Handling one typically follows a sequence of detection, triage, mitigation, resolution, and review. The review, often called a postmortem, documents the timeline and contributing causes so that improvements target the conditions that allowed the failure rather than the individuals involved.
Kill Switch: A kill switch is a single control that halts a system's activity immediately, used when continued operation is causing harm. Unlike a gradual rollback, it prioritizes stopping over preserving in-flight work. In agent systems it typically stops new runs, cancels running ones, and blocks pending actions from executing.
Latency: Latency is the elapsed time between a request being issued and its response being complete. It is reported as a distribution rather than a single number, usually with percentiles such as the median, the ninety-fifth, and the ninety-ninth. In agent systems the total is dominated by the number of sequential model and tool calls rather than by raw computation.
LLM as Judge: LLM as judge is an evaluation technique in which a language model scores the output of another system against a written rubric, standing in for a human reviewer. It makes open-ended qualities such as helpfulness, tone, or faithfulness measurable at scale, and is used where no exact reference answer exists.
LLMOps: LLMOps is the practice of deploying, monitoring, and maintaining applications built on large language models once they serve real traffic. It covers prompt and configuration versioning, evaluation, cost and token tracking, latency monitoring, safety filtering, and incident response. The term borrows from MLOps and DevOps, and its boundaries are loosely defined and vary between teams and vendors.
Mean Time to Recovery: Mean time to recovery is the average elapsed time between the start of a service impairment and the restoration of normal service. It is measured across a set of incidents over a period and is used to characterize how quickly an organization contains failures, as distinct from how often failures occur.
Monitoring: Monitoring is the continuous collection and evaluation of signals about a running system to determine whether it is behaving as expected. It focuses on known indicators such as error rate, latency, saturation, and traffic, checked against defined thresholds. Monitoring answers whether something is wrong, while broader observability practice is concerned with explaining why.
Multi-Tenancy: Multi-tenancy is an architecture in which one deployment of a system serves many independent customers, called tenants, whose data and activity must remain separated. Isolation can be enforced at the row, schema, database, or infrastructure level, with stronger separation costing more to operate. Every query, cache key, background job, and log line must carry tenant context or isolation fails.
Observability: Observability is the degree to which the internal state of a running system can be understood from the data it emits, mainly logs, metrics, and traces. A system is observable when an operator can answer new questions about a failure without shipping new code to collect more data. It is a property of the system, not a single tool.
Offline Evaluation: Offline evaluation measures the quality of an AI system against a fixed, pre-collected dataset, without exposing any real user to the version being tested. Because inputs and scoring criteria are held constant, it isolates the effect of a change to the prompt, model, or code. It is the standard gate before a change reaches production traffic.
Online Evaluation: Online evaluation measures the quality of an AI system using real production traffic as it happens, rather than a stored test set. Signals come from user behavior, explicit ratings, downstream outcomes, and automated scoring applied to live outputs. It captures the real input distribution that a fixed dataset cannot represent.
Orchestration Engine: An orchestration engine is infrastructure that coordinates multi step processes, deciding what runs next, tracking each step's state, and handling retries, timeouts, and recovery after a crash. It separates the definition of a process from the machinery that reliably executes it. Common examples include workflow engines for business processes, job schedulers for data pipelines, and coordinators for multi step agent runs.
Poison Message: A poison message is a queued item that a consumer cannot process successfully no matter how many times it retries, because the failure is caused by the message itself rather than by a transient condition. Left unhandled, it is redelivered indefinitely, consuming capacity and blocking progress for other work.
Postmortem: A postmortem is a structured written review conducted after an incident, recording what happened, the timeline, the contributing causes, the impact, and the specific changes that will reduce recurrence. Its output is a durable document and a set of owned action items, not a verdict on individual performance.
Prompt Cache Hit Rate: Prompt cache hit rate is the proportion of input tokens served from a provider's cached prefix rather than processed fresh. Many model providers cache the computed state of a repeated prompt prefix and meter those tokens differently from new ones. A higher hit rate typically reduces both latency and metered input cost.
Queue: A queue is a buffer that holds units of work between the component that produces them and the components that process them. It decouples arrival rate from processing rate, so bursts are absorbed rather than dropped, and it allows work to be retried or redistributed if a processor fails. Queues are a foundational building block for background jobs and asynchronous agent execution.
Quota: A quota is a fixed allowance of a resource granted to an account, tenant, or workload over a defined period, such as requests per day, tokens per month, or concurrent runs. Once consumed, further use is refused or degraded until the period resets. Quotas bound cost and enforce fair sharing between tenants.
Rate limit: A rate limit caps how many requests or how much usage a caller may consume in a time window, for example requests per minute or tokens per minute. Limits protect shared capacity, enforce fair access, and bound cost. Callers that exceed a limit typically receive a rejection response that indicates when the request may be retried.
Retry policy: A retry policy defines when a failed operation is attempted again, how many times, how long to wait between attempts, and which failures are eligible. Transient failures such as timeouts and rate limit rejections are usually retried, while validation errors and permission denials are not. Without a bounded policy, retries can multiply load and turn a small fault into an outage.
Rollback: A rollback is the act of returning a system to a previously known good version after a change causes problems. It is the primary mitigation during deployment related incidents because it restores service without requiring the cause to be understood first. Rollback is only genuinely available when every change in the release is reversible, which database migrations and irreversible side effects can prevent.
Runbook: A runbook is a written procedure for handling a specific operational situation, listing the steps to diagnose and resolve it in order. It exists so that a responder who did not build the system can act correctly under time pressure, without reconstructing knowledge that someone already has.
Scheduled Job: A scheduled job is work that runs automatically at defined times or intervals rather than in response to a user request. Typical uses include generating reports, synchronizing data, sending digests, cleaning up expired records, and triggering recurring agent tasks. Because no person is waiting on the result, failures are easy to miss unless the schedule is explicitly monitored.
Service Level Objective: A service level objective is a target value for a measured indicator of service quality over a defined period, such as a percentage of requests served successfully within a latency threshold each month. The indicator itself is the service level indicator, and the gap between the target and perfection is the error budget. Objectives convert vague reliability goals into numbers that guide decisions.
Shadow Deployment: A shadow deployment runs a new version of a system on real production traffic while discarding its output, so users continue to receive results from the existing version. It reveals how the candidate behaves on true inputs without exposing anyone to its mistakes. The two sets of outputs are then compared offline.
Span: A span is a single timed operation inside a trace, such as one model call, one database query, or one tool invocation. It records a start time, a duration, a name, a status, and structured attributes, and it points to its parent span. Spans nested under one another form the tree that makes up a complete trace.
Synthetic Monitoring: Synthetic monitoring runs scripted transactions against a system on a schedule, from outside it, to verify that critical paths still work. Because the checks run continuously whether or not real users are active, they detect breakage during quiet periods and cover flows that real traffic exercises too rarely to reveal a problem promptly.
Throttling: Throttling is the deliberate slowing or deferral of work to keep a system within a safe operating range. Rather than refusing requests outright, a throttled system delays them, processes them at a reduced rate, or moves them to a lower priority lane. It trades latency for stability and cost control.
Throughput: Throughput is the amount of work a system completes per unit of time, expressed as requests per second, tasks per hour, or tokens per second. It is a property of the system under a given load, and it is limited by the slowest shared resource. Throughput and latency are related but distinct, and improving one can worsen the other.
Time to first token: Time to first token is the delay between sending a request to a language model and receiving the first piece of the streamed response. It captures queueing, prompt processing, and any preliminary work, but not the time spent generating the rest of the output. It is the main determinant of how responsive a streaming interface feels.
Token usage: Token usage is the count of tokens a language model reads and writes for a request, normally reported as separate input and output totals. Tokens are subword units, so counts depend on the tokenizer as well as on text length. Usage is the main driver of both cost and latency in model-backed systems, and it is usually metered per request.
Tracing: Tracing records the path of a single request or task through a system as a tree of timed operations. Each trace carries an identifier that links every step, so a slow or failed run can be inspected end to end. In agent systems a trace typically covers model calls, tool calls, retries, and any handoffs between components.
Uptime: Uptime is the proportion of a period during which a system is available for use, usually stated as a percentage. It is commonly expressed in nines, where ninety nine point nine percent allows roughly forty three minutes of downtime per month. The number is only meaningful alongside its definition, since what counts as available and where it is measured vary widely.
Webhook Delivery: Webhook delivery is the mechanism by which one system notifies another of an event by sending an HTTP request to a receiver supplied URL. It replaces polling with push, so the receiver learns about changes promptly. Reliable delivery requires signature verification, retries with backoff, duplicate tolerance on the receiving side, and a record of attempts that can be inspected and replayed.
Worker: A worker is a process that pulls units of work from a queue or schedule and executes them outside the request and response path. Workers are typically run as an interchangeable pool, so capacity is adjusted by changing how many exist and how many items each handles at once. They are the standard place to run long jobs such as agent runs, report generation, and data synchronization.
Workflow: A workflow is a defined sequence of steps that accomplishes a process, including the order of steps, the conditions that route between them, and the handling of failures. It can be expressed as code, as a declarative graph, or as a visual diagram. Making a process an explicit workflow gives it a stable identity that can be versioned, executed repeatedly, monitored, and audited.

AI Workforce

Adoption Curve: An adoption curve is a graph of how many people or teams have taken up a new technology over time, typically S-shaped: slow at first, steep in the middle, then flattening. The concept comes from diffusion of innovations research and is used to describe both market-wide uptake of AI and internal rollout within a single organization.
Agent KPI: An agent KPI is a quantitative measure used to judge whether an automated worker is producing the intended result. Common examples include completion rate, escalation rate, correction rate, and time to first output. Measures borrowed directly from human performance frameworks often transfer poorly, because the failure modes are different.
Agent Marketplace: An agent marketplace is a catalog where prebuilt agents or agent configurations can be browsed and added to a workspace, usually organized by role or by task. Listings may come from the platform vendor, from third party developers, or from other customers. What a listing actually contains varies: some are complete agents, others are only instructions or a bundle of tools.
Agent Onboarding: Agent onboarding is the setup period in which a newly created agent receives the context, access, and boundaries it needs to do a job: reference documents, credentials scoped to that role, written procedures, and rules covering what requires approval. It normally includes a supervised phase in which output is reviewed before it is used or sent anywhere.
Agent Skill Library: An agent skill library is a collection of packaged procedures an agent can load when a task calls for one, each describing how to carry out a specific job step by step. Skills are kept separate from the agent's standing instructions so that only the relevant ones occupy its working context. A library can be shared across several agents and across teams.
Agent Template: An agent template is a reusable configuration for an agent, typically holding a role description, instructions, a default set of tools, attached procedures, and permission defaults. Creating an agent from a template copies those settings into a new instance. Templates make setup repeatable, and because the copy is usually independent, later edits to the template may not reach agents already created.
Agent Training: Agent training refers to improving an agent's behavior after setup by supplying documents, examples, and corrections that it can retrieve or that are folded into its instructions. In most business products this does not change the underlying model at all. The word is used loosely, so it is worth asking whether a feature stores knowledge, edits instructions, or genuinely fine tunes a model.
AI Adoption: AI adoption is the process by which an organization moves from experimenting with AI tools to depending on them for real work, including choosing use cases, granting access to systems, writing procedures, training people, and setting review and approval rules. It is measured by which work actually runs through the tools, not by how many licenses were purchased.
AI Assistant: An AI assistant is a system that responds to requests expressed in natural language, usually through a conversational exchange, and may call tools or search sources to produce an answer. The defining pattern is that it waits to be asked and returns a result. It is the broadest term in this area and covers everything from a simple chatbot to a tool using agent.
AI Copilot: An AI copilot is an assistant embedded inside an application that offers suggestions in place while a person works, with that person accepting, editing, or rejecting each one. The name comes from code completion tools and now covers writing, spreadsheet, design, and support software. The defining property is that the human stays in control of every change.
AI Employee: AI employee is an informal industry term for a software agent configured like a role rather than a tool, with a job title, a defined scope of duties, access to named systems, and someone it reports to. The phrase has no technical standard. It usually signals that the agent holds ongoing responsibility for a stream of work instead of answering one request at a time.
AI in Customer Support: AI in customer support refers to the use of language models and agents across support work: answering common questions directly, drafting replies for a human agent to review, summarizing conversation history, tagging and routing incoming tickets, and surfacing relevant documentation. Deployments range from fully automated first response to assistance that never reaches the customer without human review.
AI Maturity: AI maturity describes how far an organization has progressed toward using AI systematically, usually expressed as stages running from ad hoc individual use to governed, measured, and integrated use. Many consultancies and vendors publish maturity models and their stage definitions differ. No standard model exists, so a stage label is only meaningful alongside the model it came from.
AI Operating Model: An AI operating model is the documented arrangement of people, processes, tools, and decision rights that determines how an organization puts AI systems to work. It answers who may deploy an agent, which processes agents are allowed to touch, who reviews their output, and how results are measured. It is an organizational design artifact rather than a technical one.
AI Policy: An AI policy is an internal document stating how members of an organization may and may not use AI systems in their work. It typically covers approved tools, data that may not be submitted, disclosure expectations, review requirements for external output, and who to ask when a situation is unclear. Its usefulness depends on being specific.
AI Readiness Assessment: An AI readiness assessment is a structured review of whether an organization has the data, documented processes, systems access, and governance needed to deploy AI agents successfully. It produces a picture of current gaps rather than a recommendation to buy anything. Findings usually point to unglamorous prerequisites such as undocumented procedures or scattered records.
AI Teammate: AI teammate is a positioning term for an agent that participates in a team's existing channels and tools rather than sitting behind a separate interface. It is addressed in a shared inbox, chat channel, or project board, keeps context across an exchange, and can be assigned work like any other participant. The phrase describes placement and etiquette, not capability.
AI Workforce: An AI workforce is a set of software agents operated together under shared management: defined roles, common access rules, and a single record of what each agent did. The phrase borrows workforce planning language and applies it to software. It describes how agents are organized and supervised rather than any specific model, framework, or vendor technology.
Always On Operations: Always on operations means running a function continuously, so that work arriving at any hour is picked up rather than queued until the next working day. Software systems can do this because they do not depend on a working schedule. Continuous operation brings its own requirements: monitoring, limits on what may happen unsupervised, and a reliable way to reach a person when one is needed.
Augmentation: Augmentation describes an arrangement in which software handles part of a task while a person retains judgment and final decision over the outcome. In common industry usage it is contrasted with full automation, where a process runs end to end without human involvement. The distinction is one of degree, and most real deployments sit somewhere between the two.
Autonomy Expansion: Autonomy expansion is the practice of increasing an agent's independence in defined stages as evidence of reliability accumulates, rather than granting full independence at deployment. A typical sequence moves from observation only, to drafts requiring approval, to independent action within limits, to independent action with sampled review. Each stage has entry criteria and a route back.
Business Process Automation: Business process automation is the automation of an end to end business process rather than an individual task, covering the handoffs between systems, the steps performed by people, the exception paths, and the reporting on how the process performs. It normally begins with mapping the process, then automating the segments that are stable enough to be encoded.
Capacity Planning For Agents: Capacity planning for agents is the practice of estimating how much work automated processes can absorb within acceptable time and quality limits, and provisioning accordingly. Unlike planning for people, the binding constraints are usually rate limits, concurrency ceilings, budget caps, and the throughput of any human review step in the path.
Change Management: Change management is the discipline of helping people adopt a new way of working, covering communication, training, feedback channels, and support during a transition. In AI deployments it addresses the gap between a system that technically works and one that people actually use. It predates AI by decades and its established methods apply largely unchanged.
Coverage: Coverage is an operations term for the share of incoming work and operating hours that are actually attended to. A channel is fully covered when every item arriving on it is seen and handled within the intended time. Gaps in coverage show up as unanswered messages, unattended queues, and work discovered long after it arrived.
Digital Worker: Digital worker is an industry term for an automated software unit packaged as a role rather than as a single task script, typically given a name, an assigned process, and its own system credentials. It came out of robotic process automation vendors and is now applied to model based agents as well. Usage differs widely between vendors.
Escalation Path: An escalation path is the predefined route by which work moves from an automated process to a person, specifying the trigger conditions, the recipient, the context transferred, and the fallback when the recipient is unavailable. It is the mechanism that keeps a case from stalling silently when a system reaches the limit of what it should decide.
Exception Handling: Exception handling, in a workforce context, is the defined treatment of cases that fall outside a process's normal path. It specifies how an unusual case is detected, where it is routed, and what happens to it while it waits. Coverage of exceptions, not of the standard path, usually determines whether an automated process is trustworthy.
First Contact Resolution: First contact resolution is the share of customer issues fully resolved during the initial interaction, with no follow up, transfer, or callback required. It is a long established support metric that correlates strongly with customer satisfaction. Definitions of the measurement window vary between organizations, which makes benchmark comparison unreliable.
Multi-Agent Team: A multi-agent team is an arrangement in which several agents with different roles work on related tasks, passing work and context between them instead of one agent doing everything. Roles are typically split by function, such as research, drafting, and checking, or by domain. Coordination is handled either by a designated lead agent or by a predefined sequence.
No-Code Automation: No-code automation refers to building automations through a visual interface, connecting prebuilt blocks and filling in configuration instead of writing code. Tools in this category cover app to app integrations, form and approval routing, internal apps, and increasingly agent configuration. The intent is to let the person who understands the process build it without waiting for a developer.
Pilot Program: A pilot program is a deliberately narrow first deployment of an AI agent, limited to one process, one team, or one customer segment, run for a fixed period with defined success criteria. Its purpose is to produce evidence about real behavior under real conditions before wider commitment. A pilot that cannot fail is not a pilot.
Process Mapping: Process mapping is the practice of drawing a process as an ordered sequence of steps, decisions, inputs, and handoffs, usually as a diagram. It makes explicit what a procedure actually involves, including the branches that experienced staff handle without thinking. Maps are a prerequisite for delegating a process to an AI agent reliably.
Prompt Library: A prompt library is a shared, maintained collection of instructions that have been tested and found to produce reliable results, stored so that others can reuse them rather than rewriting from scratch. Entries usually carry a description of intended use, expected inputs, and notes on known limitations. Unmaintained libraries decay quickly.
Quality Assurance Review: A quality assurance review is a structured evaluation of completed work against a defined standard, performed after the work is delivered rather than before. Applied to AI agents, it means sampling finished output, scoring it on a rubric, and feeding the findings back into procedures. It differs from approval, which happens before delivery.
Robotic Process Automation: Robotic process automation is a technique in which software drives existing applications through their user interfaces, clicking, typing, and reading the screen the way a person would, in order to move data between systems that offer no usable integration. Scripts are recorded or built step by step. Because they depend on the interface staying the same, they break when a screen changes.
Scope Of Work: A scope of work is a written statement of what a worker or system is responsible for, what falls outside that responsibility, and what standard the output must meet. Applied to an AI agent, it bounds which tasks it may perform, which systems it may touch, and which decisions it must refer to a person.
Service Catalog: A service catalog is a published list of the services a team offers, each with a description, who may request it, what the requester must supply, and the expected turnaround. Applied to AI agents, it states plainly what work can be requested from them. The concept comes from IT service management and transfers with little modification.
Shadow Mode: Shadow mode is a deployment arrangement in which an agent processes real work and records what it would have done, but its output is never delivered or acted upon. The existing process continues unchanged alongside it. The purpose is to gather evidence about real behavior on real inputs at no operational risk.
SLA For Automated Work: An SLA for automated work is a stated commitment about the timeliness and quality of output produced by automated processes, along with what happens when the commitment is missed. It differs from a traditional service level agreement chiefly in that response speed is rarely the constraint, so accuracy and coverage commitments carry more weight.
Standard Operating Procedure: A standard operating procedure is a written, step by step description of how a recurring task is carried out, covering the inputs required, the order of steps, the decision points, and what to do when a case falls outside the normal path. Its purpose is to make a task repeatable by someone other than the person who invented it. It is the usual prerequisite for delegating work to anyone, software included.
Task Delegation: Task delegation is the transfer of responsibility for a piece of work to someone or something else, along with the context, authority, and constraints needed to finish it. A delegation is complete when the receiver knows the intended outcome, what may be decided alone, what needs approval, and when to hand the work back. Incomplete delegation is the usual cause of unusable output.
Task Inventory: A task inventory is a written list of the discrete units of work a team performs, usually recorded with frequency, duration, inputs, and owner. It is compiled before deciding what to delegate to AI agents, so that choices rest on observed volume rather than impression. The exercise routinely surfaces recurring work nobody had named.
Team Lead Agent: A team lead agent is an agent whose job is coordinating other agents: interpreting an incoming request, deciding which specialist should handle it, passing along the context that specialist needs, and assembling or checking the result. It performs little of the underlying work itself. The pattern is also called a supervisor or orchestrator, and the three names are used interchangeably.
Ticket Deflection: Ticket deflection is the resolution of a support request through self-service or automated response so that it never enters a human agent's queue. Deflection rate is the share of contacts handled this way. The metric is widely reported and easy to inflate, because an abandoned request and a resolved one can look identical in the data.
Time To Value: Time to value is the elapsed period between starting to adopt a system and receiving the first measurable benefit from it. In AI workforce deployments it is usually measured from initial setup to the first piece of real work completed to an acceptable standard. It is a commonly quoted metric with no standardized definition of the endpoint.
Virtual Agent: A virtual agent is a customer facing conversational system that handles inquiries in chat, voice, or messaging, resolves the requests it is equipped for, and routes the rest to a person. The term comes from contact center software and predates language models. Modern virtual agents usually combine retrieval from a knowledge base with the ability to act on business systems.
White Label AI: White label AI is the practice of offering an AI product under another company's brand, so the reseller's customers see the reseller's name, colors, and domain rather than the original vendor's. It is common among agencies and software companies bundling AI into their own offering. What can be rebranded varies, from the interface alone to the full experience including email and documentation.
Work Journal: A work journal is a chronological record of what an agent did, when, on whose instruction, and with what result. It is written for human reading rather than for machine parsing, and it is the primary artifact used to answer questions about past agent activity. It is distinct from a technical execution log.
Workflow Automation: Workflow automation is the practice of encoding a sequence of steps in software so that a trigger starts it and each step runs identically every time, without a person moving the work along. Typical steps create records, send messages, move files, and update systems. Because the sequence is defined in advance, the result is predictable and repeatable.

Channels and Interfaces

Adaptive Card: Adaptive Cards are an open card exchange format, originated by Microsoft, in which content and layout are described in JSON and rendered natively by whichever host application receives them. The same payload can appear in different hosts, each applying its own styling. They are widely used for interactive messages and dialogs in Microsoft Teams and related surfaces.
App Home: App Home is a dedicated per-application space inside a chat platform, most prominently in Slack, where an installed app presents its own persistent view to an individual user. It typically combines a direct message conversation with the app and a rendered tab that the app publishes and updates. It gives a chat-installed app a stable place to live beyond message history.
Barge In: Barge in is the ability of a voice system to let a speaker interrupt while it is talking, stopping its own audio and processing what was said. Without it, callers must wait for a prompt to finish before responding. Supporting barge in requires detecting genuine speech during playback and separating it from the system's own audio echo.
Business Hours Routing: Business hours routing sends an incoming contact down a different path depending on the time it arrives, evaluated against a defined schedule. Inside published hours it follows the normal flow; outside them it reaches an alternative such as an asynchronous handler, a message capture, or a booked callback. The schedule carries time zones, holidays, and exceptions.
Calendar Integration: Calendar integration is the connection between an application and a calendar service so it can read events, check availability, and create or update bookings. It uses provider APIs or open standards, with authorization granted by the calendar owner. For an assistant, the calendar is both a source of context and the place where scheduling decisions are recorded.
Call Deflection: Call deflection is the practice of offering an inbound caller an alternative route to resolution, such as a text conversation, a self-service link, or a scheduled callback, instead of continuing to hold on the line. The caller chooses whether to accept. Deflection is measured by resolution on the alternative path, not simply by calls leaving the queue.
Callback Scheduling: Callback scheduling lets an inbound caller hang up while keeping their position in a queue, then receive a return call when their turn arrives or at a time they choose. The queue continues to advance in the caller's absence. It exists in two forms: an immediate virtual queue callback and a booked callback at a future slot.
Canned Response: A canned response is a stored, reusable message that can be inserted into a conversation instead of being written from scratch. Most implementations support placeholders that fill in details such as a name, order number, or link at insertion time. They are also called saved replies or macros, and macros often bundle actions alongside the text.
Channel Routing: Channel routing is the logic that decides where an inbound message or call goes and which path the reply returns on. Rules can consider the channel it arrived on, the content of the request, the customer's identity or value, language, working hours, and current load. Routing also covers escalation, when a conversation is handed to a different handler.
Chat Widget: A chat widget is the embeddable chat interface that appears on a website or in an application, usually as a launcher button in a corner that opens a conversation panel. It is delivered by a small script or an inline frame and connects the page to a messaging backend. The widget is the presentation layer, separate from whatever answers the messages.
Chatbot: A chatbot is a software application that holds a text conversation with a person through a messaging interface. Implementations range from rule based systems that match keywords to scripted replies, through to systems driven by large language models that generate each response. The word describes the interface and product form, not any particular underlying technology.
Co-Browsing: Co-browsing is a session in which a helper views, and sometimes interacts with, the same web page a visitor is on, scoped to that page rather than the visitor's whole device. Implementations either mirror the page structure to reconstruct it remotely or stream pixels of the page region. Field masking is a standard requirement so sensitive values never leave the visitor's browser.
Conversation Thread: A conversation thread is the ordered sequence of messages that belong to a single exchange, together with the identifiers that keep them grouped. Threads give an assistant the history it needs to interpret references such as 'that one' or 'the second option.' Platforms implement threading differently, from email headers to explicit thread objects in chat systems.
Conversational AI: Conversational AI is the field of software that interprets human language input and responds in natural language across text or speech. It covers the components that make dialogue work, including language understanding, dialogue management, response generation, and, for voice, speech recognition and synthesis. The term describes a capability rather than a single product or architecture.
Deep Link: A deep link is a URL that opens a specific location inside an application rather than its default entry screen. Implementations range from custom URL schemes to verified web links that open the app when installed and the website otherwise. Deep links are how a conversation hands the user to the exact record, screen, or thread being discussed.
DTMF: DTMF, short for dual-tone multi-frequency, is the signaling scheme that turns a telephone keypad press into a pair of simultaneous tones. Each key combines one tone from a low group and one from a high group, so a receiver can identify the digit unambiguously. It remains the standard way callers enter numbers and menu choices on a voice call.
Email Agent: An email agent is a system that monitors a mailbox, interprets incoming messages, and acts on them by replying, filing, extracting data, or triggering downstream work. It connects through a mail protocol or provider API and works within an email thread rather than a live chat session. Actions may be sent automatically or held for a person to review.
Embedded Assistant: An embedded assistant is an assistant that lives inside a host application and has access to that application's context and actions. Unlike a general chat interface, it can read what the user is currently viewing and operate on it, for example editing a record or filtering a report. The assistant is a feature of the product it sits in.
Endpointing: Endpointing is the decision a voice system makes about when a speaker has finished their turn and a response should begin. It combines silence timing with acoustic and linguistic cues to separate a natural mid-sentence pause from a genuine handoff. Getting it wrong produces either interruptions or noticeable dead air.
Inbound Email Parsing: Inbound email parsing is the process of turning a received email into structured data an application can use. It separates headers, the new message body from quoted history, signatures, inline images, and attachments, then usually delivers the result to an application as a webhook payload or an API object. It is the entry step for any system that acts on email.
Interactive Voice Response: Interactive voice response is a phone system that plays recorded or synthesized prompts and collects caller input, traditionally as keypad tones and increasingly as speech. It uses that input to route the call or to complete a simple transaction such as checking a balance. Classic interactive voice response follows a fixed decision tree defined in advance.
Meeting Assistant: A meeting assistant is a system that joins or connects to a video or audio meeting to capture what is said and produce usable output afterward, such as a transcript, a summary, and action items. It typically joins as a participant through a calendar invitation, or connects through the conferencing platform's own recording interface.
Meeting Transcription: Meeting transcription is the conversion of a multi speaker conversation into a written record, usually with speaker labels and timestamps. It combines speech recognition with diarization, the task of determining who spoke when, and often adds punctuation and paragraph structure. Accuracy depends on microphone setup, overlapping speech, and how familiar the vocabulary is.
Microsoft Teams App: A Microsoft Teams app is a package installed into a Teams tenant that can add a conversational bot, tabs, message extensions, or interactive cards. It is described by a manifest, distributed through an organization catalog or the public store, and governed by tenant administrators. Identity and permissions come from the organization's directory.
Omnichannel: Omnichannel describes an approach where every contact surface, such as chat, email, phone, and messaging apps, feeds one shared record of the customer and their history. A conversation started in one channel can continue in another without the person repeating themselves. It contrasts with multichannel, where the same channels exist but each keeps its own separate history.
Push Notification: A push notification is a message delivered to a device through a platform push service rather than requested by the application itself. The app registers for a token, a server sends a payload addressed to that token, and the operating system displays or delivers it even when the app is closed. Web browsers support an equivalent mechanism through their own push services.
Push To Talk: Push to talk is a voice input mode where the user holds or taps a control to mark exactly when they are speaking. The microphone captures audio only within that window, so the system never has to infer where an utterance begins or ends. It is the deterministic alternative to wake words and automatic endpointing.
Queue Position: Queue position is the ordinal place a waiting contact holds in a line, often announced together with an estimated wait time. Position comes directly from queue depth and ordering rules, while the estimate is derived from recent handling times and available capacity. The two are frequently confused, and only the first is exact.
Quick Reply: A quick reply is a tappable suggested answer presented to the user alongside a message, usually as a row of short chips. Selecting one sends that value as the user's next message, so the conversation stays in the message stream rather than opening a separate form. Most platforms treat quick replies as transient and hide them once a choice is made.
Read Receipt: A read receipt is a signal reporting that a recipient's client has displayed a message, usually shown as a status marker beside it. Platforms typically distinguish several states, such as sent, delivered to the device, and read. The read state indicates rendering on screen, which is not the same as a person having taken in the content.
Real-Time Transcription: Real-time transcription converts speech to text continuously while a person is still speaking, emitting provisional results that are revised as more audio arrives. It differs from batch transcription, which processes a complete recording after the fact and can use the whole file as context. The live variant trades some accuracy for immediacy.
Rich Card: A rich card is a structured message unit combining elements such as a title, description, image, and action buttons into a single rendered block. Several cards shown in a horizontally scrollable row form a carousel. Cards let a conversational surface present selectable options and records without leaving the message stream for a separate page.
SIP Trunk: A SIP trunk is a virtual connection that carries phone calls between an organization's phone system and a voice service provider over an IP network. Session Initiation Protocol handles call setup and teardown while the audio itself travels as RTP media streams. It replaces the physical circuits that older systems used to reach the public telephone network.
Slack App: A Slack app is an integration installed into a Slack workspace that can post messages, respond to events, add slash commands, and render interactive surfaces. It authenticates with scoped tokens granted at install time and receives activity through the events subscription or a socket connection. Apps act under their own identity or, with permission, on a user's behalf.
Slash Command: A slash command is a text command typed in a chat composer, beginning with a forward slash, that invokes a registered handler instead of sending an ordinary message. The platform parses the command name and any arguments, then delivers a structured payload to the application that registered it. Responses can be private to the invoker or visible to the whole conversation.
SMS Agent: An SMS agent is a system that sends and receives text messages over the mobile carrier network and responds automatically. It works through a phone number or short code supplied by a messaging provider, which delivers inbound messages to an application and relays outbound replies. Message length limits, carrier rules, and consent requirements shape what it can do.
Speaker Diarization: Speaker diarization is the process of partitioning an audio recording by speaker, answering who spoke when without necessarily knowing who anyone is. It segments the audio, embeds each segment as a voice representation, and clusters those embeddings into anonymous speaker labels. Attaching real names to those labels is a separate step called speaker identification.
Speech to Text: Speech to text is the conversion of spoken audio into written text by an automatic speech recognition model. Systems output words along with timings and often a confidence score, and may operate on a completed recording or on a live stream. Accuracy varies with audio quality, accent, vocabulary, background noise, and how many people are speaking.
Telegram Bot: A Telegram bot is an automated account on Telegram controlled through the platform's bot API. It receives updates either by long polling or by a webhook, and replies with messages, media, inline keyboards, or files. Bots can operate in private chats, groups, and channels, and what they can see inside a group depends on their privacy setting.
Telephony Integration: Telephony integration is the connection between software and the telephone network so that a program can place calls, receive them, and control audio in real time. It typically uses a session protocol such as SIP or a provider API that abstracts it, together with phone numbers, call routing rules, and media streaming. This is the plumbing behind any automated phone line.
Text to Speech: Text to speech is the generation of spoken audio from written text. Neural synthesis models produce speech with natural rhythm and intonation, and can be steered by voice selection, speaking rate, and markup that controls pauses or emphasis. Streaming synthesis begins producing audio before the full text is ready, which matters for live conversation.
Turn: A turn is one contribution to a conversation by one party, followed by the other party's opportunity to respond. In text systems a turn is usually a single message, while in speech it is a stretch of talk bounded by the speaker yielding the floor. Counting turns is how dialogue systems measure conversation length and structure context.
Typing Indicator: A typing indicator is a transient signal shown in a conversation to convey that the other party is composing a message. It is usually sent as an ephemeral event with a short expiry, refreshed while composition continues and cleared when the message is sent or abandoned. Most platforms never store these events in the message history.
Voice Activity Detection: Voice activity detection is the frame-by-frame classification of an audio stream into speech and non-speech. It runs ahead of transcription and other processing so that silence, noise, and background sound can be skipped. VAD supplies the raw speech and silence signal that endpointing, barge-in handling, and bandwidth control all build on.
Voice Agent: A voice agent is a system that holds a spoken conversation, converting the caller's speech to text, deciding on a response, and speaking that response back. It runs over a phone line, a web audio session, or a device microphone. Beyond answering questions, most voice agents can take actions such as booking, looking up records, or transferring the call.
Voice Cloning: Voice cloning is the creation of a synthetic voice that reproduces the timbre and speaking style of a specific person, built from recorded samples of that person. Some systems need hours of studio audio, while others approximate a voice from a short clip. The resulting voice can then read arbitrary text supplied by whoever controls it.
Voice Latency: Voice latency is the delay between a speaker finishing and the system starting to respond audibly. It accumulates across the whole path: audio transport, endpointing, speech recognition, response generation, speech synthesis, and playback. Because spoken conversation has short natural gaps, latency is one of the strongest determinants of whether a voice interaction feels workable.
Wake Word: A wake word is a short spoken phrase that a device or application listens for in order to activate its full voice pipeline. A small always-on detector runs continuously on a local audio buffer and only opens the main recognition path once the phrase matches, which keeps compute low and limits how much audio ever leaves the device.
Warm Transfer: A warm transfer is a call handoff in which the transferring party first speaks privately with the destination, passes context, and only then connects the caller. It contrasts with a cold or blind transfer, where the call is redirected immediately with no consultation. Warm transfers preserve continuity at the cost of a longer handoff.
WhatsApp Business API: The WhatsApp Business API is the programmatic interface Meta provides so businesses can send and receive WhatsApp messages at scale. Inbound messages reach the business as webhook events, and replies are sent through API calls from a verified business account with a registered phone number. It is distinct from the consumer app and from the standalone WhatsApp Business app.