AI in Testing

A/B testing for AI models runs two model versions (or two prompts, or two configurations) against live traffic simultaneously, routing a portion of real users to each, and compares outcome metrics between the groups — measuring real-world impact rather than offline benchmark scores, which don't always predict how a change performs in production.

Agent memory testing checks whether an AI agent correctly stores, retrieves, and uses information across a conversation or task — confirming it remembers what actually happened earlier rather than either forgetting relevant context or "remembering" something that was never said.

Agent orchestration testing verifies the layer that routes tasks between multiple AI agents — deciding which agent runs next, passing state between them, and handling retries or timeouts — separately from testing what any individual agent does. It's closer to testing a workflow engine than testing a model.

Agent trajectory evaluation scores the full sequence of steps, tool calls, and intermediate decisions an agent took to reach its final answer — not just whether the final answer was correct — since two agents can reach the same right answer through very different paths, only some of which are actually acceptable.

Agentic testing uses autonomous AI agents that can plan, execute, and adapt a multi-step testing process with minimal human direction — exploring an application, deciding what to test next based on what they observe, and adjusting when something unexpected happens. It differs from scripted automation, which only ever does exactly what it was explicitly told to do.

Agentic workflow testing validates an end-to-end multi-step process an AI agent plans and executes on its own — breaking a goal into subtasks, choosing an order, acting, and adjusting based on results — rather than testing a single prompt-response exchange.

AI adversarial testing deliberately crafts inputs designed to fool a model into making mistakes — a slightly perturbed image that causes misclassification, a carefully worded prompt that triggers unintended behavior — probing how robust a model is against inputs specifically engineered to break it, not just naturally occurring edge cases.

An AI agent evaluation harness is the testing infrastructure built specifically to assess an autonomous AI agent's performance across a suite of tasks — measuring success rate, efficiency, and safety of its actions — accounting for the fact that an agent's exact path to a goal can vary between runs.

AI bias testing evaluates whether a model's outputs systematically favor or disadvantage particular groups — based on race, gender, age, or other protected characteristics — often unintentionally inherited from patterns in its training data, checking for fairness the model wasn't explicitly designed to consider.

AI code review uses a large language model to automatically analyze code changes — flagging potential bugs, security issues, style violations, and suggesting improvements — as a first-pass complement to human code review, not a full replacement for it.

AI in software testing refers broadly to the use of machine learning and generative AI to assist or automate testing activities — generating test cases, healing broken locators, evaluating outputs a simple assertion can't judge, and exploring applications autonomously — a fast-growing set of techniques reshaping how testing gets done.

An AI model card is a standardized document that reports a model's intended use, training data characteristics, evaluation results, known limitations, and fairness or bias findings, published alongside the model so anyone integrating it — including QA — knows what it was actually tested for before treating it as a black box.

AI model monitoring is the ongoing, automated tracking of a deployed model's key metrics — accuracy proxies, latency, error and refusal rates, cost per request, and drift indicators — against defined thresholds, with alerting when a metric moves outside its expected range.

AI model regression testing verifies that a new version of a model — retrained, fine-tuned, or swapped for a different provider — doesn't perform worse than the previous version on the tasks that matter, using a consistent golden dataset and evaluation criteria across versions to make the comparison meaningful.

AI risk assessment is the structured process of identifying what could go wrong with an AI feature before it ships — harmful or biased outputs, privacy leakage, security exposure via prompt injection, over-reliance by users — and rating each risk's likelihood and severity so testing effort is directed at the highest-impact failure modes first.

An AI test agent is a software agent powered by a large language model that can autonomously plan and execute testing tasks — navigating an application, deciding what to check, and adapting based on what it observes — rather than following a fixed, pre-written script.

AI test case prioritization ranks a test suite by predicted likelihood of catching a defect in the current change, using signals like which files changed, historical failure patterns, and code coverage overlap, so the highest-value tests run first, especially under a tight CI time budget.

An AI test oracle uses a machine learning model — often another LLM — to judge whether a test's actual output is correct, especially for outputs too subjective or too varied for a simple equality check, like evaluating whether a generated summary is accurate or a chatbot's response is appropriately helpful.

AI-based flaky test detection analyzes historical test run data to identify tests that fail intermittently for reasons unrelated to the code under test — timing races, network hiccups, animation delays — and flags or quarantines them automatically, instead of a human noticing the same test "randomly" failing over weeks.

AI-generated edge case testing uses a generative model to propose unusual, boundary, or adversarial test inputs for a system under test — rather than a human manually brainstorming them — by prompting the model to produce inputs likely to break a described function, API, or UI flow based on patterns learned from real-world bugs.

An autonomous testing agent operates with minimal human direction — setting sub-goals, executing multi-step plans, and adapting its approach based on results — the most independent end of the AI test agent spectrum, distinguished from simpler tools that still need a human to define each specific step.

A benchmark dataset is a fixed, standardized set of inputs and expected outputs used to measure and compare AI model performance on a specific task, allowing different models or versions to be scored against the same yardstick rather than each being judged on its own ad hoc examples.

Bias mitigation testing verifies that fixes applied to reduce an AI model's unfair output — reweighted training data, output filters, prompt adjustments — actually reduced the measured bias without introducing new problems or simply hiding it, by re-running the same bias evaluation before and after the fix and comparing results.

BLEU score is an automated metric that scores how closely a machine-generated text output matches one or more reference texts by comparing overlapping word sequences (n-grams), originally built for machine translation and still used as a cheap, if imprecise, proxy for output quality in AI testing.

A canary release for an AI model rolls out a new version to a small percentage of real production traffic first, monitoring its metrics closely before gradually increasing exposure — limiting the blast radius of a bad model update the same way a canary release limits the blast radius of a bad application deploy.

Chain-of-thought evaluation checks not just whether a model's final answer is correct, but whether its intermediate reasoning steps are logically valid and actually lead to that answer — catching cases where a model reaches the right conclusion through flawed reasoning, or shows sound-looking steps that don't actually support its final output.

Champion-challenger testing runs a candidate model (the "challenger") against the current production model (the "champion") on live traffic or a shared evaluation set, comparing their outcomes head-to-head to decide whether the challenger should replace the champion — a structured, ongoing version of an A/B test built specifically for model iteration.

Chatbot testing verifies that a conversational AI system responds appropriately across a range of user inputs — correctly understanding intent, staying on topic, handling ambiguous or off-topic questions gracefully, and maintaining coherent context across a multi-turn conversation.

Chunking strategy testing evaluates how a RAG system's choice of chunk size, overlap, and splitting logic (by paragraph, sentence, token count, or semantic boundary) affects retrieval quality and downstream answer accuracy — since the same source documents can perform very differently depending on how they're cut into retrievable pieces.

Citation accuracy testing verifies that when an AI system cites a source — a document, a page number, a URL — that source actually exists, actually contains the claim being attributed to it, and is the real source that was retrieved, rather than one that sounds plausible but was fabricated.

Concept drift testing checks for cases where the relationship between input and correct output has changed over time — even if the input data itself looks statistically similar — so a model that was accurate when trained becomes systematically wrong simply because the world it's modeling has moved on.

Confidence calibration testing checks whether a model's stated confidence (or its output probability) actually matches its real accuracy — a well-calibrated model that says it's 90% confident should be right about 90% of the time, not 60% or 99%. Miscalibration means the confidence score is decorative rather than trustworthy.

Context window testing verifies how a model behaves as the amount of information in its context (conversation history, retrieved documents, system instructions) approaches or exceeds its maximum context length — checking for degraded accuracy, forgotten instructions, or dropped information as context grows large.

Conversational AI testing evaluates multi-turn dialogue systems broadly — voice assistants, chatbots, AI copilots — covering not just individual response quality but the coherence, appropriateness, and reliability of an entire conversation across many exchanges.

Copilot-assisted test automation uses AI coding assistants — GitHub Copilot and similar tools — to help write, complete, and refactor automated test code, speeding up test authoring while still relying on a human to review, run, and validate the generated tests actually do what's intended.

Data drift detection monitors whether the statistical distribution of a model's incoming input data is shifting away from the distribution it was trained or validated on — a leading indicator that model performance may be about to degrade, even before that degradation shows up in accuracy metrics.

Embedding quality testing checks whether the vector representations a RAG or search system uses to compare text actually place semantically similar content close together and dissimilar content far apart — since a retriever is only as good as the embeddings it ranks candidates by, regardless of how well the rest of the pipeline is built.

Exact match evaluation scores a model's output as correct only if it matches a reference answer character-for-character (or after light normalization like case-folding), making it the strictest and simplest automated metric — well suited to tasks with one unambiguous correct answer, and badly suited to almost everything else.

Explainability testing checks whether a model can produce a human-understandable account of why it reached a particular output — a rationale, a cited source, or a feature-importance breakdown — and whether that account is actually accurate, rather than a plausible-sounding story generated after the fact.

Fairness testing checks whether a model's outputs or decisions differ systematically across demographic groups — race, gender, age, accent, name origin — in ways that aren't justified by the actual task, such as a resume screener consistently ranking equivalent resumes lower based on the name at the top.

Few-shot prompt testing evaluates how a model's output quality changes when a prompt includes a small number of example input/output pairs before the real request, checking both that the examples actually improve performance and that the model doesn't overfit to quirks of the specific examples chosen.

Function calling testing checks that a model correctly translates a natural-language request into a structured function call — the right function name, correctly typed arguments matching a defined schema — since most agent and tool-use systems depend on this structured output being valid before anything downstream can run.

Generative AI test case generation uses a large language model to automatically draft test cases from requirements, user stories, or existing code — producing a first-pass set of scenarios, including edge cases a person might not immediately think of, for a human to review and refine.

A golden dataset is a curated, trusted set of input-output pairs used as the fixed reference point for evaluating an AI model's performance — the AI-testing equivalent of a regression suite, run consistently across model or prompt versions to track quality over time.

Ground truth testing compares a model's output against a verified, known-correct answer — established by human experts or an authoritative source — to measure factual accuracy, distinguishing genuinely correct output from merely plausible-sounding output an AI test oracle alone might not catch.

Groundedness testing checks whether an AI-generated answer is actually supported by the source material it was given — retrieved documents, provided context — rather than drifting into the model's own unverified internal knowledge. It's distinct from hallucination testing, which checks factual correctness regardless of source.

Guardrail testing verifies that an AI system's safety mechanisms — content filters, topic restrictions, refusal behaviors — actually work as intended, correctly blocking harmful, off-topic, or out-of-scope requests without also incorrectly blocking legitimate ones.

Hallucination testing checks whether an AI model generates confident-sounding output that's factually incorrect, unsupported by its source material, or entirely fabricated — like citing a paper that doesn't exist or stating a wrong number with total confidence. It's one of the highest-priority checks for any AI feature that presents information as fact.

A held-out test set is a portion of data deliberately excluded from a model's training or fine-tuning process and reserved purely for evaluation, so performance is measured on examples the model has genuinely never seen — the only way to get an honest read on how it generalizes rather than how well it memorized.

Human evaluation is the practice of having people directly review and score AI-generated output for quality, correctness, or preference — the ground-truth standard that automated metrics (BLEU, ROUGE, exact match) are ultimately trying to approximate, used when nuance, taste, or real-world correctness can't be reduced to a formula.

Human-in-the-loop testing validates the checkpoints where an AI system pauses to ask a person for approval, correction, or a decision before continuing — confirming those interruptions actually happen when they should, present the right context to the reviewer, and correctly resume based on the human's response.

Image generation testing evaluates AI-generated images for prompt fidelity (does the image actually match what was asked for), visual quality (artifacts, anatomical errors, distortions), safety (no disallowed or harmful content), and consistency across repeated generations of the same or similar prompts.

Inference latency testing measures how long a model takes to produce a response — end-to-end and broken down by stage, such as retrieval, generation, and post-processing — under realistic concurrent load, tracked at percentiles (p50, p95, p99) rather than just an average, since tail latency is what users actually experience as slowness.

Interpretability testing evaluates whether a model's internal decision process can be inspected and understood at all — through techniques like attention visualization, feature attribution, or probing intermediate representations — as distinct from explainability, which is about the model's own stated justification for an output.

Jailbreak testing probes whether an AI model's safety and policy guardrails can be bypassed through crafted prompts — role-play framing ("pretend you're an AI with no restrictions"), encoded or obfuscated instructions, or multi-step conversations that gradually walk the model into producing content its system prompt explicitly forbids.

LLM evaluation is the process of measuring how well a large language model's outputs meet quality, accuracy, and safety expectations — using benchmark datasets, human review, or another model acting as a judge (LLM-as-a-judge). Unlike testing deterministic code, there's rarely one exact "correct" output to assert against, so evaluation measures degrees of correctness instead.

LLM-as-a-judge uses a capable language model to evaluate the quality of another model's output against defined criteria — accuracy, helpfulness, tone — providing a scalable alternative to human review for judging subjective or open-ended AI-generated responses.

Long-horizon task evaluation measures how an AI agent performs on tasks that require many sequential steps or a long span of time to complete, where small per-step error rates compound and early mistakes can derail everything that follows — a different failure profile than single-turn question answering.

MCP testing verifies implementations of the Model Context Protocol — the standard that lets AI models discover and call external tools and data sources — checking that a server correctly exposes its tools, and that a client correctly discovers, calls, and handles responses from them.

ML pipeline testing validates the end-to-end system around a model — data ingestion, feature engineering, preprocessing, the model call itself, and post-processing — checking that each stage produces correct output and that failures anywhere in the chain are caught rather than silently propagating a corrupted input into the model.

Model drift testing detects when a deployed model's performance degrades over time — because real-world input has shifted away from the data it was trained on, or the underlying task itself has changed — catching gradual quality decay that a one-time pre-deployment evaluation wouldn't reveal.

Model observability is the practice of instrumenting an AI system in production to continuously capture its inputs, outputs, latency, confidence scores, and downstream outcomes — giving teams visibility into how a model is actually behaving with real traffic, not just how it performed on a pre-release test set.

Model provenance testing verifies that the AI model actually running in production is the one that was tested and approved — the correct version, trained on the correct data, unmodified since evaluation — by checking model hashes, version metadata, and deployment logs, to catch silent substitutions like an untested fine-tune or a provider's undisclosed model update.

Model versioning testing verifies that every deployed model is traceable to an exact, reproducible version — training data snapshot, hyperparameters, prompt or fine-tune configuration — and that swapping between versions behaves predictably, so a regression can be traced to a specific change and rolled back with confidence.

Multi-agent testing checks a system where several AI agents work together — each with its own role, tools, and reasoning loop — to confirm the group actually completes the task correctly, not just that each agent behaves well in isolation. Most failures happen at the handoffs between agents, not inside any single one.

Multi-turn conversation testing evaluates a model's behavior across an extended back-and-forth exchange rather than a single prompt-response pair — checking whether it maintains context correctly, stays consistent with earlier statements, and doesn't degrade in quality or safety as the conversation gets longer.

Multimodal AI testing evaluates models and features that combine multiple input or output types — text, images, audio, video — checking not just each modality in isolation but whether the system correctly reasons across them, like describing what's actually in an image rather than a generic guess based on the surrounding text.

Natural language test case authoring lets testers write test steps in plain English — "log in, add an item to the cart, verify the total updates" — which an AI layer then translates into executable automation code, removing the requirement to hand-write Selenium or Playwright scripts for every scenario.

Non-deterministic output testing addresses the challenge that AI models can produce different, valid outputs for the exact same input on different runs — meaning traditional exact-match assertions don't work, and evaluation needs a different approach, like similarity scoring or a rubric-based judge, instead.

OCR (optical character recognition) accuracy testing measures how correctly a system extracts text from images or scanned documents, tracked via character error rate and word error rate against a hand-verified ground-truth transcript, across the fonts, layouts, handwriting, and image quality the system will actually encounter in production.

Out-of-distribution (OOD) testing checks how a model behaves on inputs that differ meaningfully from its training or evaluation data — an unfamiliar language, an unusual input format, a topic it was never exposed to — since accuracy on familiar data says nothing about behavior once real-world input drifts outside that range.

Pairwise comparison evaluation shows a rater — human or an LLM judge — two candidate outputs for the same input and asks which one is better, rather than asking for an absolute quality score on a scale, since people (and models) are typically far more consistent at relative comparisons than at assigning stable absolute ratings.

PII leakage testing checks whether an AI model exposes personally identifiable information it shouldn't — training data it memorized, another user's data from a shared context window, or details it can be prompted into revealing — by deliberately probing it with prompts designed to extract sensitive information.

Prompt engineering for QA is the practice of designing and refining prompts used to instruct AI systems for testing purposes — generating test cases, evaluating outputs, or driving an AI test agent — where the quality of the prompt directly determines the quality and reliability of the AI's output.

Prompt injection testing probes whether user input can override an AI system's original instructions — tricking it into ignoring its guardrails, revealing its system prompt, or performing an action it was explicitly told not to. It's the AI-era equivalent of SQL injection: untrusted input manipulating a system that wasn't built to distinguish instructions from data.

Prompt regression testing re-runs a fixed, versioned set of prompts against a model whenever the prompt, model version, or surrounding system changes, and compares the new outputs against known-good baselines — catching cases where a change that fixed one behavior silently broke another.

Prompt template testing validates the reusable prompt structures an application builds at runtime — the fixed instructions plus variable slots for user input, retrieved context, or chat history — checking that they render correctly for edge-case inputs like empty values, special characters, or very long strings, and still produce the intended model behavior once filled in.

Prompt-based test generation uses natural-language prompts to instruct an AI model to produce test cases, test scripts, or test data — letting a tester describe what they want tested in plain language rather than manually writing each test case or script by hand.

RAG testing verifies Retrieval-Augmented Generation systems — which fetch relevant documents before generating a response — checking both that retrieval finds the right source material and that the generated answer is actually grounded in what was retrieved, rather than drifting back to the model's own unverified internal knowledge.

Rate limit testing for AI APIs verifies how a system behaves when it hits a provider's requests-per-minute or tokens-per-minute ceiling — whether it queues gracefully, retries with backoff, degrades to a smaller model, or fails the user outright. It matters more for AI features than typical APIs because LLM limits are often lower and errors less predictable.

Red teaming is the practice of deliberately trying to make an AI system fail — produce harmful, biased, incorrect, or policy-violating output — using adversarial prompts and creative attack strategies, in order to find and fix weaknesses before real users (or real bad actors) find them.

Responsible AI testing evaluates an AI system against ethical and safety criteria — fairness across user groups, transparency about AI involvement, avoidance of harmful content, respect for user privacy — in addition to standard functional correctness, treating "does it behave responsibly" as a testable requirement rather than a policy afterthought.

Retrieval precision measures what fraction of the documents or chunks a RAG system retrieves for a given query are actually relevant to answering it — a low-precision retriever pulls in noise alongside anything useful, forcing the model to sort signal from irrelevant context, which increases the risk of an ungrounded or distracted answer.

Retrieval recall measures what fraction of the actually relevant documents or chunks for a given query a RAG system's retriever successfully finds — a low-recall retriever misses relevant information entirely, which no amount of good generation downstream can fix, since the model can only work with what it was given.

ROUGE score is an automated metric, most common in summarization testing, that measures how much of a reference text's content (words, phrases, or word sequences) is captured in a generated summary — emphasizing recall of the source's key content over exact wording.

Self-healing test automation uses AI — usually a model trained on the DOM or accessibility tree — to automatically update a test's element locators when the underlying UI changes slightly, such as a button's ID changing while its text and position stay the same, instead of the test failing and requiring a manual fix.

Semantic similarity testing measures whether two pieces of text mean roughly the same thing, even if worded differently, using embedding-based comparison rather than exact string matching — essential for evaluating generative AI output, where a correct answer can be phrased in many valid ways.

Shadow deployment testing runs a new model version in production alongside the live model, feeding it the same real traffic, but without serving its responses to users — comparing its outputs against the current model's to validate real-world behavior before it's ever actually exposed.

Speech-to-text testing measures transcription accuracy (via word error rate) across the accents, background noise levels, speaking speeds, and audio quality a system will actually face in production, along with latency for real-time use cases and correct handling of domain-specific vocabulary, names, and jargon.

Synthetic test data generation uses AI or algorithmic techniques to create realistic but artificial test data — mimicking the shape, variety, and statistical distribution of real data without containing any actual real user information, sidestepping both privacy risk and the manual effort of hand-crafting large datasets.

Synthetic user testing uses AI-generated simulated users — driven by an LLM prompted to behave like a specific persona — to interact with a product the way a real user would, generating realistic usage paths and edge cases at a volume and speed no human test team could match, before or alongside real user testing.

System prompt testing verifies that a model's system-level instructions — its persona, rules, and constraints, set by the application rather than the user — are actually being followed under normal use and are resilient against a user's conversational attempts to override or ignore them.

Temperature is a generation parameter that controls how random or deterministic an LLM's output is — near 0 makes the model consistently pick its most likely next token, while higher values let it sample less-likely tokens more often for more varied, less predictable output — and it's one of the first things QA needs to control for in testing.

Test impact analysis maps which tests actually exercise which parts of the codebase, via code coverage data or static and dynamic dependency analysis, so a given code change only needs to trigger the tests that cover the changed code instead of the entire suite.

Text-to-speech testing evaluates generated audio for pronunciation accuracy (especially names, acronyms, and numbers), naturalness of prosody and pacing, correct handling of punctuation-driven pauses, and consistency of a chosen voice across long or varied input.

Token cost evaluation measures how much a test suite or production feature actually costs to run against an LLM, based on the number of input and output tokens consumed per call, multiplied by the provider's per-token pricing. It turns "does this feature work" into "does this feature work at a cost that scales," a question functional tests never answer alone.

Token-level evaluation analyzes a language model's output at the granularity of individual tokens — the confidence or probability the model assigned to each generated token — rather than judging only the final assembled response, useful for detecting uncertainty or potential hallucination the surface text alone doesn't reveal.

Tool-use evaluation checks whether an AI agent picks the right external tool (a search API, a calculator, a database query) for a given task, calls it with correctly formatted arguments, and correctly interprets the result — independent of whether its final natural-language answer sounds right.

Toxicity testing checks whether a model's outputs contain harassment, hate speech, explicit content, or other harmful language — either because a user prompted for it directly or because the model produced it unprompted while generating otherwise-normal content. It's typically measured with both automated classifiers and human review.

Vector database testing verifies that a system storing embeddings (for RAG, semantic search, or recommendation) returns the right neighbors for a given query vector — checking index accuracy, latency under load, and that updates and deletes are reflected correctly, since a wrong or stale vector index quietly breaks every downstream AI feature built on it.

Visual AI testing uses machine learning to detect meaningful visual differences in an application's UI — distinguishing genuine visual bugs from harmless rendering noise (anti-aliasing, minor font rendering variance) — a smarter evolution of pixel-by-pixel visual regression testing.

Zero-shot evaluation tests a model's ability to perform a task correctly with no task-specific examples in the prompt — just an instruction — measuring how well it generalizes from its underlying training rather than from in-context demonstrations, and serving as a baseline to compare against few-shot performance.