AI Terms Glossary: 100+ AI, LLM and Agent Terms

The vocabulary around AI moved faster than the documentation did. A single design review can now mix retrieval, evaluation, agent orchestration, and prompt security, and the same word often means different things to the people in the room.

This glossary defines 173 terms across large language models, agents, retrieval, evaluation, and generative AI, written for engineering and QA teams who have to build and test these systems rather than describe them.

The agent-to-agent protocol is an emerging standard for agents built on different frameworks to discover each other and exchange tasks. It makes cross-vendor agent interaction testable as a contract rather than a bespoke integration.

Agent functional testing verifies that an agent completes defined tasks correctly against stated acceptance criteria. Assertions target the observable outcome and the actions taken, since the route between them varies by run.

An agent handoff is the transfer of a task and its context from one agent to another. It is a routine failure point, because context that was implicit for the sending agent is missing for the receiving one.

The agent loop is the repeating cycle of observe, decide, act, and evaluate that continues until a goal is reached or a stop condition fires. Loop limits exist because without them a stuck agent will retry indefinitely.

Agent plugins extend a coding agent with packaged commands, tools, and configuration that install as a unit. They make an agent setup reproducible across a team rather than living in one engineer's local config.

Agent skills package procedural knowledge into an agent, while MCP connects an agent to external tools and data. They solve different problems and are commonly used together rather than chosen between.

Agent smoke testing runs a shallow, wide check that an agent starts, reaches its tools, and completes a simple task end to end. It answers whether a deployment is worth testing further, not whether it is correct.

An agent team is a set of agents working the same task under a coordinator, each with a defined role and scope. Adding agents adds coordination cost, so a team only outperforms one agent when the work genuinely splits.

Agent-first development treats the agent as the primary implementer and the human as reviewer and gatekeeper. It changes where effort is spent, moving it from writing code to specifying intent and verifying results.

Agent-native describes a tool built so an agent is a first-class user: machine-readable interfaces, structured results, and permissions an agent can operate under. It is a stronger claim than AI-native, which usually means a model was added to an existing product.

An agent-native architecture exposes capability through typed, discoverable interfaces rather than screens intended for people. The properties worth testing are discoverability, idempotency, permission scoping, and whether errors are legible to a model.

Agentic AI describes systems that plan, select tools, and act across multiple steps toward a goal rather than returning one response to one prompt. The same request can take a different path each run, which is what makes outcome-based assertions necessary.

Agentic automation replaces fixed scripted paths with an agent that chooses its own route to a stated outcome. It absorbs interface changes that would break a script, and it gives up the exact reproducibility a script provides.

Agentic QA is the operating model where agents handle generation, execution, and triage while humans own intent, gates, and escalation. The QA role shifts from writing every case to defining what correct means and reviewing what the agent concluded.

Agentic regression testing checks that an agent still behaves acceptably after a model, prompt, or tool change. Because output varies between runs, the comparison is a score against a baseline rather than a match against stored text.

Agentic test management applies agents to the planning layer: deciding what to test, maintaining the case inventory, and mapping coverage to requirements. It targets the effort spent maintaining a suite rather than the effort spent running it.

Agentic testing uses an autonomous agent to carry out the test rather than replaying a fixed script. The agent resolves elements at run time, adapts when the interface changes, and returns an evidence-backed verdict instead of a line-number failure.

An agentic workflow lets a model choose the sequence of steps toward a goal instead of following a fixed script. The same request can take a different route each run, which is precisely what makes it powerful and hard to test.

AGENTS.md is a repository file that tells coding agents how to work in that codebase: commands, conventions, and constraints. Treated well it is a testing contract, not a style note.

An AI agent is a program that uses a model to decide its next action, calls tools or APIs to carry it out, and repeats until a goal is met or a limit stops it. What separates an agent from a chatbot is that it acts on the world rather than only returning text.

AI agent testing verifies what an agent actually did, not only what it replied. It covers tool calls, intermediate state, recovery from a failed step, and whether the agent stayed inside its permitted scope across a full multi-turn run.

An AI chatbot answers in natural language using a model rather than a decision tree, so it can handle phrasings nobody scripted. That same flexibility is why its failure modes are open-ended rather than enumerable.

AI code review reads a diff and comments on correctness, style, and risk. It catches a different class of defect from verification: review inspects the code as written, while verification observes what the code does when it runs.

AI code security addresses the risks specific to model-generated code: invented dependencies, insecure defaults reproduced from training data, and secrets pasted into prompts. Volume is the aggravating factor, since review capacity does not scale with generation speed.

AI context is the total information a model has for a given call: the system prompt, conversation history, retrieved documents, and tool results. Its composition determines answer quality more reliably than model choice does.

AI model testing evaluates a trained model rather than the software around it, measuring accuracy, bias, drift, and robustness against adversarial or out-of-distribution inputs. A model can pass every unit test in the codebase and still answer wrongly in production.

AI testing is the use of machine learning and large language models inside the testing process itself, to generate cases, resolve elements, triage failures, or decide what to run. It describes a method, not a subject, and is distinct from testing a product that contains AI.

AI testing data security governs what test data may be sent to a model provider, how it is retained, and which controls apply. It is the constraint that decides whether a team can use a hosted model at all or must self-host.

AI-generated code defects cluster differently from human ones, favouring plausible-but-wrong API use, silent edge-case omissions, and tests that assert almost nothing. Knowing the distribution is what makes review of generated diffs efficient.

Alignment is the work of making a model's behaviour match human intent and stated values. It is a training-time property, which is why applications still need enforced guardrails at run time.

An application programming interface is the contract through which one piece of software calls another. For agents it is the surface that turns a suggestion into an action, which is why API permissions decide an agent's real blast radius.

Automation ROI compares the cost of building and running automation against the manual effort it removes and the defects it prevents. For agent-based automation the calculation has to include inference cost per run, which does not shrink with scale the way script execution does.

An autonomous agent pursues a goal without step-by-step human direction, deciding its own actions until it finishes or is stopped. Most production systems described this way are partially autonomous, with a human gate on the consequential steps.

Autonomy level describes how much an agent decides for itself, from suggestion only, through act-with-approval, to fully unattended. Naming the level explicitly is what makes the risk of a deployment discussable.

Barge-in lets a caller interrupt a prompt and be understood immediately rather than waiting for playback to end. Getting it wrong produces the two most common voice complaints: an agent that talks over the user, or one that ignores them mid-prompt.

A browser agent operates a real browser, reading the page and clicking, typing, and navigating to complete a task. It differs from a script by resolving elements at run time rather than replaying stored selectors.

A canary prompt is a known input with a known good answer, run continuously against production to detect silent degradation from a model update or a configuration change.

Chain-of-thought prompting asks a model to work through intermediate reasoning before answering. It improves accuracy on multi-step problems, and the stated reasoning is a description of the answer rather than proof of how it was reached.

Chatbot automation testing drives conversations programmatically and asserts on responses, intents, and transitions. It makes regression coverage practical for a surface where the input space is effectively unbounded.

Chatbot test cases cover intent coverage, entity extraction, context retention across turns, fallback handling, and escalation to a human. Single-turn cases miss the defects that only appear once a conversation carries state.

Chatbot testing validates conversational systems across intent recognition, multi-turn context, fallback behaviour, and handoff to a human. Single-turn assertions miss most real defects, which appear only once a conversation has state.

Chunking splits source documents into retrievable segments before embedding. Chunk size and overlap decide whether retrieval returns a complete thought or a fragment, and it is the most under-tuned parameter in most RAG systems.

Churn prediction estimates which customers are likely to leave within a given window so retention effort can be targeted. Its accuracy decays as customer behaviour shifts, making drift monitoring part of the deployment rather than an afterthought.

A citation is the reference an agent returns alongside a claim, pointing to the retrieved source it came from. Citations are only meaningful when verified, since a model can produce a plausible reference to a document that says nothing of the kind.

Codeless testing removes the scripting step entirely, capturing or generating tests through a recorder or natural-language input. Its long-term cost sits in how the tool handles maintenance once the interface changes.

A coding agent reads a repository, plans a change, edits files, and runs commands to verify its work. Its output is a diff, which makes review and independent verification the binding constraint on how fast it can be adopted.

Hooks are deterministic rules that fire at defined points in an agent's loop, such as before a file write or after a command. They enforce policy the model cannot negotiate with, which is what makes agent behaviour auditable.

Contact center testing validates the full customer path across IVR, queueing, agent handoff, and CRM integration. Each component can pass alone while the handoffs between them fail.

Context engineering is the practice of deciding what information reaches a model's context window, in what order, and at what cost. It replaces prompt wording as the main lever once a system has memory, retrieval, and tools.

The context window is the maximum number of tokens a model can consider at once, covering the system prompt, conversation, retrieved documents, and the reply. Everything outside it is invisible to the model, no matter how relevant.

Continuous agent testing runs agent evaluations on a schedule or on every change rather than before a release. Because model providers update independently of your code, an unchanged system can regress without any commit.

Continuous verification runs an automated proof of behaviour on every change rather than at release checkpoints. For agent-written code it is the gate that decides whether a diff is mergeable, since review capacity does not scale with generation speed.

Conversational AI covers systems that hold a multi-turn exchange in text or speech, tracking context across turns rather than answering each message in isolation. State across turns is where most of its defects live.

A copilot is an assistant that suggests while a person remains in control and accepts or rejects each suggestion. It sits one step below an agent, which acts without asking at each step.

A cost guardrail caps spend per request, per session, or per day, and stops execution when the limit is reached. Without one, a looping agent's failure mode is an invoice.

Cursor rules are project-level instructions that shape how an AI editor writes code in a given repository, covering conventions, constraints, and files to avoid. They are the editor equivalent of an AGENTS.md contract.

A deterministic system returns the same output for the same input every time. Model-backed systems are not deterministic, which is why their tests assert on properties and thresholds rather than on exact strings.

Distillation trains a smaller model to reproduce a larger model's outputs, keeping most of the capability at a fraction of the serving cost. It is how most low-latency production models are produced.

Dual-tone multi-frequency signalling is the tone pair a phone sends when a caller presses a key. IVR tests assert on DTMF handling because tones can be missed, doubled, or arrive during a prompt that has not finished.

An embedding is a numeric vector representing the meaning of text, an image, or other input, positioned so that similar items sit close together. Embeddings are what make similarity search possible without keyword overlap.

End-to-end agent testing follows a full user path through every system an agent touches, including the tools and services behind it. It catches integration failures that single-agent tests cannot see.

Episodic memory stores specific past interactions as discrete events an agent can recall later, as opposed to facts distilled into a knowledge store. It is what lets an agent refer back to what happened in a prior session.

An escalation path defines when an agent stops and hands work to a person, and to whom. Defining it before deployment is what separates a controlled failure from an unbounded one.

An eval scores model or agent output against defined criteria rather than comparing it to one expected string. Scoring is rule-based, model-graded, or both, and the dataset behind it decides whether the numbers mean anything.

The executor is the component that carries out a planned step, calling the tool and returning the result to the loop. Keeping it separate from the planner is what allows a step to be retried without replanning the whole task.

A fallback is the defined behaviour when the primary path fails: a smaller model, a cached answer, a human handoff, or an explicit refusal. Systems without one fail by improvising, which is the worst available option.

Few-shot prompting includes a small number of worked examples in the prompt so the model infers the pattern and the output format. It usually beats longer instructions for formatting and edge-case behaviour.

Fine-tuning continues training a base model on a task-specific dataset so the behaviour is baked into the weights rather than supplied at run time. It buys consistency and lower per-call cost, at the price of a training cycle every time requirements change.

A flaky agent test passes and fails against unchanged code because the agent took a different route or phrased its answer differently. The fix is usually a weaker assertion on the right property, not a retry.

Function calling is the provider-level implementation of tool calling: the model emits a structured call against a declared schema instead of free text. The application, not the model, decides whether to execute it.

Generative AI testing covers both using generative models to produce test assets and validating systems that generate content. In the second case output is open-ended, so correctness is scored against criteria rather than matched to a stored string.

A golden dataset is a curated set of inputs with reviewed correct outputs, used as the reference for evaluation. It is the artifact that decays fastest, because product behaviour moves and the dataset does not unless someone maintains it.

Grounding ties a model's output to verifiable source material, usually retrieved documents or tool results. An answer is grounded when every claim in it can be traced to something the system actually retrieved.

Guardrails are the constraints placed around a model's inputs and outputs: allowed topics, blocked content, schema validation, spend caps, and permitted tools. They are enforced outside the model, because a model cannot be trusted to enforce limits on itself.

A hallucination is confident output unsupported by the model's sources or by reality, such as an invented function, citation, or dependency. It is the failure mode that makes unreviewed model output unsafe to ship.

A human-in-the-loop design requires a person to approve, correct, or veto an action before it takes effect. It is the standard containment pattern for any step whose cost of being wrong exceeds the cost of waiting.

Hybrid search combines keyword and vector retrieval, then merges the results. It covers the weakness of each: exact identifiers that embeddings miss, and paraphrases that keyword search misses.

An idempotent operation produces the same result whether it runs once or many times. It matters for agents because retries are routine, and a non-idempotent action such as sending an email or charging a card can be executed twice.

Intent recognition classifies what a user wants from what they said, mapping open phrasing onto a defined action. Its accuracy sets the ceiling for a conversational system, since a misread intent makes every later step wrong.

Intent-based testing describes what a test must prove rather than the steps and selectors used to prove it. The resolver re-derives the path each run, so a refactor that changes structure without changing behaviour does not turn the suite red.

An interactive voice response system routes callers through recorded menus using keypad or spoken input. It is rule-driven and finite, which is what distinguishes it from an intelligent virtual agent that interprets open speech.

IVR automation testing drives call flows programmatically, sending keypad tones or synthesized speech and asserting on what the system plays back. It replaces manual dial-and-listen passes that cannot cover a menu tree of any size.

IVR performance testing measures behaviour under concurrent call load: answer latency, prompt delay, transfer success, and audio degradation. Voice systems fail differently under load, dropping quality before they drop calls.

IVR testing places real calls through a phone system and verifies menu routing, prompt playback, input handling, and transfer behaviour. It has to run over telephony rather than an API, because the defects live in the audio path.

A jailbreak is an input crafted to bypass a model's safety training and elicit output it was aligned to refuse. It differs from prompt injection in targeting the model's policy rather than the application's instructions.

JSON mode is a provider setting that forces syntactically valid JSON. It guarantees the output parses, not that the values are correct or that the schema is respected, so validation is still required.

A knowledge base is the curated corpus an agent retrieves from, distinct from the model's training data. Its freshness and structure determine answer quality more than model choice does in most retrieval applications.

The knowledge cutoff is the date beyond which a model's training data ends. Anything after it must be supplied through retrieval or tools, and models frequently answer confidently about periods they were never trained on.

Latency is the time between a request and a usable response. For agents it compounds, because every tool call and every reasoning step adds a round trip that the user waits through.

Lead scoring ranks prospects by likelihood to convert, using a model over behavioural and firmographic signals. It is a common first production use of machine learning because the cost of an individual wrong score is low.

A large language model is a neural network trained on very large text corpora to predict the next token. Everything an LLM appears to know is encoded in its weights, which is why it can be fluent and wrong at the same time.

LLM test automation uses a language model to author, adapt, or execute automated tests from natural-language intent. The model resolves the specifics at run time, which is what lets a test survive markup changes that would break a stored selector.

Low-rank adaptation fine-tunes a model by training a small set of added parameters instead of updating all the weights. It makes task-specific adaptation affordable and keeps the base model reusable.

Low-code test automation exposes a visual or declarative authoring layer over a scripting engine. The trade-off is extensibility, since complex logic still needs an escape hatch into real code.

Machine learning in testing applies trained models to test selection, failure clustering, flakiness prediction, and element matching. Its accuracy depends on the quality and freshness of the historical run data it learns from, unlike rule-based automation.

Max tokens caps the length of a model's response. Set too low it truncates answers mid-sentence, and a truncated JSON response fails to parse rather than failing loudly.

The Model Context Protocol is an open standard that lets an agent discover and call external tools, data sources, and services through one interface, instead of a custom integration per tool.

An MCP client is the agent-side component that connects to MCP servers, discovers what they offer, and issues calls. The client decides which servers an agent can reach, making it the effective permission boundary.

The MCP Inspector is a client for exercising an MCP server directly, listing its tools and calling them with chosen arguments. It is how a server is debugged without an agent in the loop confusing cause and effect.

MCP security covers what changes when a model, rather than a developer, decides which tool runs with which arguments. The controls that matter are tool scoping, authentication, argument validation, and an audit trail of what the agent actually invoked.

An MCP server exposes tools, resources, and prompts to any MCP-compatible client. Its tool definitions, permission model, and error handling are all testable surfaces in their own right.

Memory is the information an agent carries across turns or sessions, distinct from the context window it is given on any single call. What gets written to memory and what gets retrieved from it is a design decision, not a model capability.

A model router picks which model handles a given request, sending simple work to a cheap fast model and hard work to a stronger one. It is the most common cost optimization in production, and it introduces variance across the routing boundary.

A multi-agent system splits work across specialized agents coordinating through a protocol or an orchestrator. Its failure modes are distributed: handoffs drop context, agents duplicate work, or one agent's bad output silently becomes another's input.

Multi-agent testing verifies systems where several agents coordinate, focusing on handoffs, shared state, and conflicting actions. The defects that matter are usually in the coordination rather than in any single agent.

A multimodal model accepts or produces more than one kind of input, such as text with images or audio. Each additional modality is a separate failure surface, so evaluation has to cover them individually and in combination.

Natural language test automation lets a tester write steps in plain English that an agent resolves into actions at run time. Because resolution happens per run rather than at authoring time, the binding is to intent rather than to a selector.

No-code and low-code platforms expose a visual or declarative authoring layer over an execution engine. No-code removes scripting entirely, while low-code keeps an escape hatch into real code for the cases the interface cannot express.

Non-deterministic output means the same input can produce different valid responses across runs. It is the property that makes exact-match assertions unusable and forces tests onto schemas, invariants, and score thresholds.

Observability is the ability to understand what a system did from the signals it emits. For agents that means capturing every prompt, tool call, and intermediate result, because a final answer alone cannot explain how it was produced.

Orchestration is the layer that decides which agent or tool runs when, passes state between steps, and handles retries and failures. It is where multi-agent systems succeed or fall apart.

A persona is a defined character, tone, and knowledge boundary an agent adopts in its responses. In evaluation, personas double as test users representing distinct behaviours and needs.

The planner is the component that decomposes a goal into an ordered set of steps before execution begins. Separating planning from execution makes the intended path inspectable before any action is taken.

A pre-action check validates an agent's intended action before it executes, rather than inspecting the damage afterwards. It is the cheapest place to stop a destructive or out-of-scope operation.

Prompt caching stores the processed form of a repeated prompt prefix so later calls skip recomputing it, cutting cost and latency. Cache hits can also hide real changes during evaluation, so cached runs and fresh runs should be compared deliberately.

Prompt engineering is the practice of shaping instructions, examples, and output format to make a model's responses reliable. It is the cheapest lever available and the first one exhausted as systems grow.

Prompt injection is an attack where instructions hidden in content the model reads, such as a web page or a document, override the developer's intent. It is the defining security problem of tool-using agents, because the injected instruction can trigger real actions.

A prompt template is a parameterized prompt with defined slots for variable content, stored and versioned like code. Templates are what make prompt changes reviewable rather than invisible.

Prompt-based testing drives a system under test by prompting a model rather than by calling an API or replaying a script. The prompt becomes a versioned test asset, and changes to it need the same review as changes to code.

A quality gate is the automated check a change must clear before it can merge, expressed as thresholds rather than opinions. For AI-generated pull requests it is what replaces line-by-line human review as the binding control.

Quantization reduces the numeric precision of a model's weights so it needs less memory and runs faster. The trade-off is a small accuracy loss that matters more on reasoning tasks than on formatting ones.

A quarantine test is a known-unreliable test moved out of the blocking suite so it still runs and reports without failing the build. It is a holding state with an owner and an exit date, not a place to hide tests nobody intends to fix.

Retrieval-augmented generation retrieves relevant documents at query time and passes them to the model as context, so answers are grounded in a controlled corpus rather than in training data alone. It is the standard way to give a model access to private or current information.

A rate limit caps how many requests or tokens a client may consume in a window. Agents hit them harder than applications do, because one user request can fan out into dozens of model calls.

ReAct interleaves reasoning and acting, so the model alternates between thinking about what to do next and calling a tool to do it. Most modern agent loops are a variation on this pattern.

Red teaming attacks a system deliberately to find failures before real users or adversaries do, covering injection, jailbreaks, data exfiltration, and unsafe tool use. It is adversarial by design rather than a checklist.

A regression test confirms that a change has not broken behaviour that previously worked. For model-backed systems the comparison is a score threshold rather than exact equality, since output varies between runs.

Reranking reorders an initial set of retrieved candidates with a more expensive, more accurate model. It cheaply fixes the common case where the right document was retrieved but ranked too low to reach the context window.

Reinforcement learning from human feedback trains a model using human preference rankings between candidate outputs. It is the step that turns a raw next-token predictor into something that follows instructions.

A sandbox is an isolated environment where an agent's actions cannot touch production data or systems. It is the standard containment mechanism for any capability whose blast radius is not yet understood.

A self-healing locator re-identifies an element from surrounding attributes when its primary selector stops matching. It cuts maintenance on cosmetic changes and can mask a real regression by healing past a genuinely broken element.

Semantic search retrieves by meaning rather than by literal term match, using embeddings to find documents that answer a query even when they share no words with it.

A skill is a packaged set of instructions that teaches an agent a specific procedure and its conventions. Skills make agent behaviour reproducible across runs, which is what separates a demo from something a pipeline can depend on.

An agent service level agreement states what the operator guarantees: response latency, task success rate, escalation time, and the classes of action the agent will never take unattended. Agents are probabilistic, so an agent SLA is stated as a rate rather than an absolute.

A small language model trades breadth for lower latency, lower cost, and the option to self-host. Routing narrow, well-specified tasks to one is the most common way to cut inference spend without a measurable quality loss.

Spec-driven development writes a precise, machine-readable specification before implementation and treats it as the source an agent builds and verifies against. The specification, not the prompt, is the artifact under version control.

The Web Speech recognition API lets a browser transcribe spoken input to text. Support and accuracy vary by browser and platform, so voice features need per-environment verification rather than a single pass.

The Web Speech synthesis API produces spoken audio from text in the browser. Available voices differ by platform, which makes pronunciation and pacing defects environment-specific.

Speech-to-text transcribes spoken audio into text for a model to process. Transcription errors propagate silently into everything downstream, which is why voice agents are evaluated on the audio and not only on the transcript.

A stop sequence is a string that ends generation as soon as the model produces it. It is how output is bounded when a length limit would truncate mid-structure.

Streaming returns tokens as they are generated instead of waiting for the full response. It improves perceived latency and complicates error handling, since a failure can arrive after output has already been shown.

Structured output constrains a model to return data in a defined shape, such as JSON matching a schema, rather than prose. It is what makes model output safe to parse and act on programmatically.

A subagent is an agent spawned by another agent to handle a scoped piece of work and return a result. Subagents keep the parent's context clean, and each handoff is a place where context can be lost.

A supervisor agent routes work to other agents, monitors their progress, and decides when a task is complete or must be escalated. It is the coordination point in most multi-agent designs and the natural place to enforce budgets.

Synthetic data is generated rather than collected, used to cover cases real data lacks or cannot legally supply. It fills gaps well and reproduces the blind spots of whatever generated it.

The system prompt sets a model's persistent role, constraints, and output rules for a session, ahead of any user message. It is the highest-leverage text in most applications and the most common place a regression hides.

Temperature controls randomness in token selection. Lower values make output more repeatable and are preferred for extraction and code, while higher values increase variety at the cost of predictability.

A test generation agent produces test cases from requirements, code, or observed behaviour. The risk to manage is generated suites that read convincingly while asserting almost nothing.

Text-to-speech synthesizes spoken audio from model output. Quality issues that never appear in text, such as mispronounced names or wrong emphasis, become user-visible defects here.

Throughput is how many requests or tokens a system processes per unit of time. It is the capacity constraint that decides whether an evaluation suite can run on every commit or only nightly.

A token is the unit a model reads and writes, roughly a word fragment. Tokens are the billing unit and the limit unit, so prompt design, context size, and cost are all expressed in them.

Token cost is the per-call price of input and output tokens, and it is the variable that makes agent-based execution economically different from script execution. A suite that reruns on every commit multiplies it by every retry.

Tool calling is the mechanism by which a model requests that a named function be executed with structured arguments, then continues once the result returns. It is what turns a text generator into something that can act.

A tool schema declares a tool's name, purpose, parameters, and types so a model can call it correctly. Vague descriptions are the most common cause of an agent calling the wrong tool or supplying the wrong argument.

Top-p, or nucleus sampling, limits token choice to the smallest set whose probabilities sum to a threshold. It is an alternative to temperature for controlling variability, and tuning both at once usually makes behaviour harder to reason about.

A trace is the recorded end-to-end path of a single request through an agent, including each model call, tool invocation, and result. It is the primary artifact for debugging non-deterministic behaviour after the fact.

Turn-taking is how a conversational system decides when the user has finished speaking and it should reply. Cut too early it interrupts, waited too long it feels unresponsive, and the threshold is a tested parameter rather than a fixed value.

A vector database stores embeddings and retrieves them by similarity rather than exact match. It is the retrieval layer most RAG systems are built on, and its recall quality sets the ceiling on answer quality.

Vendor lock-in is the cost of moving off a provider once prompts, tools, evaluations, and traces are shaped around it. In agent stacks the tooling and evaluation layers usually bind harder than the model itself.

Verification-driven development requires independent evidence that generated code does what was asked before it is accepted. The premise is that an agent cannot be the sole judge of its own output, so verification runs outside the process that produced the work.

Vibe coding is building software by describing intent to an AI agent and accepting generated code without reading all of it. It moves the bottleneck from writing code to verifying it, which is why it demands a stronger test gate rather than a weaker one.

Vibe testing applies the same natural-language approach to tests, describing what should be true and letting an agent produce and run the checks. The risk to manage is a suite that reads well and asserts nothing.

A vision model interprets images, reading screenshots, diagrams, and documents. In testing it enables assertions about what a screen actually shows rather than what the DOM claims it contains.

A voice agent conducts a spoken conversation end to end, transcribing what a caller says, deciding a response, and speaking it back. Every stage adds latency and its own error rate, and those errors compound down the chain.

Voice agent monitoring runs continuous synthetic calls against production to detect degradation before users report it. It catches provider-side regressions that no code change would explain.

Voice agent regression testing replays a suite of representative calls after a prompt, model, or telephony change. Because responses vary, results are scored against a baseline rather than matched to stored transcripts.

Voice agent testing evaluates spoken conversational systems end to end, covering transcription accuracy, interruption handling, latency, and response quality. Testing the transcript alone hides the failures that only exist in audio.

Voice AI is the stack behind spoken interaction: speech recognition, language understanding, dialogue management, and speech synthesis. Evaluating only the text layer hides the failures that exist purely in audio.

Voice observability captures the recording, transcript, latency at each stage, and model decisions for a call so a failure can be reconstructed afterwards. Without the audio, a transcript alone cannot explain what went wrong.

Voice quality testing measures the audio itself, covering clarity, jitter, packet loss, and distortion. A functionally correct answer delivered through degraded audio is still a failed call.

Word error rate measures transcription accuracy as the proportion of words inserted, deleted, or substituted against a reference. It is the standard speech-to-text metric, and it weights every word equally even though names and numbers matter most.

Workflow automation executes a defined sequence of steps across systems without human action at each stage. It differs from agentic behaviour in that the path is fixed in advance rather than chosen by a model.

Zero-shot prompting asks a model to perform a task with instructions only, no worked examples. It is the baseline every other prompting technique should be measured against.