AI Glossary for Product Managers: 250 Terms Explained in Plain English (2026)

Software that performs tasks we usually link with human judgment, like understanding language, recognizing images, making predictions or generating content.

Why it matters: In a job description, “AI” can mean anything from a spam filter to an autonomous agent. Ask which kind of AI the team ships before you judge the role.

A branch of AI where systems learn patterns from data instead of following rules someone wrote by hand for every case.

Why it matters: If the logic could be written as clear rules, you may not need ML at all. A PM's first question is whether the problem really needs learning from data.

A type of machine learning that uses neural networks with many layers to learn patterns from large amounts of data. LLMs, image recognition and speech recognition all run on deep learning.

Why it matters: You rarely need the math. You do need to know that deep models want lots of data and compute, and that they are hard to explain.

A model made of layers of connected numerical units that adjust their connections during training until the outputs match the examples.

Why it matters: When an engineer says the network “learned” something, it means the weights changed to fit the data. It does not mean the system understands your users.

The trained set of learned parameters that turns an input into an output, such as a prompt into an answer or a transaction into a fraud score.

Why it matters: Your product is not the model. The model is one component, and the prompt, data, interface and safeguards around it decide whether users get value.

The numbers inside a model that get adjusted during training. Model size is usually quoted in parameters, such as 8 billion or 70 billion.

Why it matters: More parameters often means better quality but higher cost and latency. Bigger is a trade-off, not a free upgrade.

The process of showing a model many examples so it adjusts its parameters to make better predictions.

Why it matters: Most product teams never train a model from scratch. They pick a trained model and adapt it with prompts, retrieval or fine-tuning.

The first and most expensive stage of building an LLM, where the model learns language by predicting the next token across huge amounts of text.

Why it matters: Pre-training is why a model knows general facts and writing styles. It's also why it knows nothing about your company's private data.

The stages after pre-training that turn a raw model into a helpful assistant, such as instruction tuning and reinforcement learning from human feedback.

Why it matters: Post-training decides tone and refusals, and how well the model follows instructions. Two models with similar pre-training can feel very different to users because of it.

Running an input through a trained model to get an output. Every chatbot reply, classification or generated summary is one inference call.

Why it matters: Inference is where your ongoing costs live. Training is a one-time bill for the model maker, but you pay for inference every time a user clicks.

A large model trained on broad data that can be adapted for many different tasks. Large language models and multimodal models are common examples.

Why it matters: Most AI features in 2026 start on a foundation model from a provider. The product work is in adapting it to one job and proving it does that job well.

A neural network trained on huge amounts of text to understand and generate language by predicting tokens. Chatbots, writing assistants and coding assistants are built on LLMs.

Why it matters: An LLM predicts likely text. It does not look up the truth. That single fact explains hallucinations, why grounding matters, and why every LLM feature needs evals.

A smaller language model, often a few billion parameters, built to run cheaply, quickly or on a device.

Why it matters: For narrow tasks like tagging tickets or pulling fields from a form, a small model can match a large one at a fraction of the cost.

The most capable models available at a given time from the leading AI labs.

Why it matters: Frontier models are the right place to prototype. They are not always the right place to scale, because their price per call is the highest.

An LLM trained to work through a problem in intermediate steps before answering, which improves results on math, code, planning and other multi-step questions.

Why it matters: Reasoning costs time and tokens. Use it where a wrong answer is expensive, not for a quick autocomplete.

A model that can take in or produce more than one type of data, such as text plus images, audio or video.

Why it matters: Multimodal opens product ideas like photo-based insurance claims or voice support, but each new input type needs its own evaluation.

AI systems that create new content, such as text, code, images, audio, video, summaries or structured outputs.

Why it matters: Generative features produce new output every time, so you can't test them like a button. You test them with evals and by reviewing samples.

The neural network architecture behind almost every modern LLM, introduced in the 2017 research paper Attention Is All You Need.

Why it matters: You won't design one. Knowing the name lets you follow engineering conversations and see that most LLMs share the same basic design.

The mechanism inside a transformer that lets the model weigh which earlier tokens matter most when producing the next one.

Why it matters: Attention is why models handle long, messy inputs well. It's also why very long prompts cost more and can bury important details in the middle.

The basic unit of text an LLM reads and writes. A token can be a word, part of a word or a punctuation mark. In English, one token averages roughly three quarters of a word.

Why it matters: Providers price and limit usage by tokens. Token counts drive your cost per request, your latency and how much text fits in one call.

The component that splits text into tokens before the model sees it. Different models use different tokenizers.

Why it matters: The same sentence can cost more tokens in one language than another. If you launch outside English, check token counts for your target languages.

The maximum number of tokens a model can consider in one request. It counts the instructions, the user's message, retrieved documents, conversation history and the answer itself.

Why it matters: The window decides how much a feature can read at once. Filling it isn't free: longer context costs more, runs slower and can dilute attention on what matters.

The date after which a model has no information from its training data.

Why it matters: If users ask about recent events, prices or policies, a model alone will answer from stale knowledge. Retrieval or live tools fix that.

The core task an LLM performs: given the text so far, predict the most likely next token, then repeat.

Why it matters: Every behavior you see, from summaries to code, comes from this one loop. That's why the model sounds fluent even when it's wrong.

A deterministic system gives the same output for the same input every time. A probabilistic system, like an LLM, can give different outputs for the same input.

Why it matters: This is the biggest mindset shift from classic PM work. You stop specifying exact behavior and start defining acceptable ranges of behavior.

A model whose trained weights are published so anyone can download it and run it on their own servers, such as Meta's Llama family.

Why it matters: Open weights give you control over data, cost and customization. In return, your team takes on the hosting and scaling, plus the safety work.

A model you can only use through the provider's API or app. The weights stay private.

Why it matters: Closed models are fast to start with and often the most capable, but you depend on the provider for pricing and policy, and you inherit every version change.

A company that offers models through an API, such as OpenAI, Anthropic, Google or Mistral.

Why it matters: Provider choice is a product decision. It affects quality, cost, data terms, uptime and which regions you can serve.

A fixed release of a model with a specific name or date, so its behavior doesn't change underneath you. Providers retire old versions on a published schedule.

Why it matters: Pin a version in production. When the provider ships a new one or retires yours, rerun your evals before you switch, because gains in one area can bring regressions in another.

A public, standardized test used to compare models, such as a set of math problems or coding tasks.

Why it matters: Benchmarks tell you how models compare in general. They don't tell you how a model performs on your users' tasks. Only your own evals do that.

A document that describes a model's intended uses, training data, known limitations and evaluation results.

Why it matters: Read the model card before you pick a model for a sensitive use case. It often lists the exact limitations your risk review will ask about.

Training a smaller model to copy the behavior of a larger one, so you keep much of the quality at lower cost and latency.

Why it matters: Distillation is a common path once a feature is proven: prototype on a big model, then move high-volume traffic to a cheaper distilled one.

Storing a model's weights with less numerical precision so it runs faster and uses less memory, with some loss in quality.

Why it matters: Quantization is how models fit on phones and laptops. Ask engineering what quality drop it causes on your own eval set.

A model design where only part of the network, a few “experts,” activates for each token, so a very large model can run at the cost of a smaller one.

Why it matters: You care about MoE only through its effects: better quality per dollar. It's a common reason one model is cheaper than another at similar quality.

A generative model that creates images, audio or video by starting from random noise and refining it step by step.

Why it matters: Image and video features run on diffusion models. Their failure modes differ from text: wrong hands, garbled lettering inside images and style drift between shots.

The field of AI that interprets images and video, such as detecting objects, reading text in photos or spotting product defects.

Why it matters: Vision features live or die on real image quality. Test with the blurry, badly lit photos real users take, not the clean demo set.

The field of AI that works with human language, covering tasks like translation or summarization. LLMs now handle most NLP tasks that once needed separate models.

Why it matters: If a team runs an old NLP pipeline, ask whether one LLM call could replace several models. Sometimes it can, and sometimes the old model is cheaper and good enough.

Automatic speech recognition turns spoken audio into text. It powers voice assistants, meeting transcripts and call analytics. Its partner, text-to-speech, turns text back into audio.

Why it matters: Transcription errors flow downstream. If your meeting summarizer is wrong, check whether the transcript was wrong first.

A type of machine learning where a model is trained on labeled examples, such as emails labeled as spam or not spam.

Why it matters: Supervised models need labeled data, and labels cost money and time. The labeling plan often decides the project timeline.

Training where a model learns by trying actions and receiving rewards or penalties, instead of copying labeled answers.

Why it matters: Reinforcement learning is behind game-playing systems and much of the post-training that makes chat models helpful. You'll mostly meet it through RLHF.

A task where a model assigns an input to a category, such as spam or not spam, urgent or routine.

Why it matters: Classification features need a decision about which mistake is worse. That choice drives your precision and recall targets.

A task where a model predicts a number, such as delivery time or next month's demand.

Why it matters: Agree on how wrong is acceptable. Predicting delivery in 30 minutes when it takes 45 might be fine for food and a failure for medicine.

Grouping similar items together without predefined labels, such as sorting support tickets into themes. It's the most common form of unsupervised learning.

Why it matters: Clustering is the engine behind many feedback analysis tools. The PM's job is naming the clusters and deciding which ones matter.

When a model learns its training examples too closely, including their noise, and performs worse on new data.

Why it matters: The product version of overfitting is tuning a prompt until it aces your ten test cases and fails on the eleventh. Keep a held-out test set.

The input you give an LLM: instructions, a question, examples and any context it needs to respond.

Why it matters: In a product, most of the prompt is written by your team, not the user. It's product logic in plain language, so it deserves review like any spec.

Instructions set by the product team that sit above every user message and define the assistant's role, rules, tone and limits.

Why it matters: The system prompt is where much of an AI feature's behavior gets specified. PMs should read it, suggest changes and track its versions.

Writing instructions, examples, constraints and context so an LLM produces better outputs.

Why it matters: In 2026, prompt engineering is table stakes for AI PMs. Prototyping a prompt yourself is the fastest way to learn what a model can and can't do before you write the PRD.

Designing the full information environment around an LLM: system instructions, user prompts, retrieved documents, memory, tool outputs and product rules.

Why it matters: Most quality problems in shipped AI features are context problems. The model didn't get the right document, the right history or the right rules. This is where PMs and engineers fix them together.

Asking a model to do a task with instructions only, no examples.

Why it matters: Start here when prototyping. If zero-shot is good enough, you save tokens and complexity.

Including a few worked examples of input and ideal output in the prompt so the model copies the pattern.

Why it matters: Few-shot examples are the quickest way to fix format and tone. Pick examples from real user inputs, including awkward ones.

A model's ability to pick up a task from instructions and examples inside the prompt, without any retraining.

Why it matters: This is why you can ship an AI feature in weeks without training anything. The catch is that every example costs tokens on every call.

A prompting approach that asks a model to reason step by step before reaching an answer, first described in a 2022 Google research paper.

Why it matters: Step-by-step reasoning improves hard tasks but adds tokens and delay. Decide whether users should see the reasoning or only the answer, because not every reasoning trace belongs in the interface.

Telling the model to act as a specific role, such as a senior support agent or a strict code reviewer.

Why it matters: Roles shape tone and focus, but they don't add knowledge. A model told it's a lawyer still doesn't know your contract.

A reusable prompt with fixed instructions and placeholders that get filled with each user's data at runtime.

Why it matters: Templates are what actually ship. Review them like code, because a small wording change can shift every response.

Splitting a task into several model calls where each output feeds the next, such as extract, then summarize, then draft a reply.

Why it matters: Chains are easier to debug than one giant prompt, because you can see which step failed. Each extra step adds latency and cost.

Model output forced into a fixed format, such as JSON with defined fields, so software can read it reliably.

Why it matters: If another system consumes the output, require structured output. Free text breaks integrations in ways demos never show.

A setting that controls randomness in a model's output. Low temperature gives focused, repeatable answers. High temperature gives more varied, creative ones.

Why it matters: Use low temperature for extraction and factual answers, and higher temperature for brainstorming or copy variations. Interviewers like asking which setting fits which feature.

A sampling setting that limits the model to the smallest set of likely next tokens whose combined probability reaches p, such as 0.9.

Why it matters: Top-p and temperature both tune randomness. Teams usually adjust one and leave the other at its default.

A cap on how many tokens the model may generate in one response.

Why it matters: Set it to protect cost and latency, but not so low that answers get cut off mid-sentence. Truncated answers look like bugs to users.

When an AI system generates an answer that sounds confident but is wrong, unsupported or made up. A support bot inventing a refund policy that doesn't exist is the classic case.

Why it matters: Hallucination is the top trust risk in most LLM products. The PM chooses the defenses: retrieval, citations, refusing when evidence is missing, and evals that measure how often it still happens.

Tying a model's answer to specific source material, such as retrieved documents or database records, instead of its general memory.

Why it matters: Grounded answers can be checked. Make “answer only from these sources” a product requirement for any feature that states facts.

Links or references in an AI answer that show which source supports each claim.

Why it matters: Citations let users verify answers and let your team audit them. Test that the cited passage actually supports the claim, because models can cite the wrong source.

A model's tendency to agree with the user or tell them what they want to hear, even when it's wrong.

Why it matters: Sycophancy hurts products that give feedback, advice or reviews. Include test cases where the user is confidently wrong.

When a model declines to answer or act, usually because of safety rules or missing information.

Why it matters: Over-refusing and under-refusing are both product bugs. Track the refusal rate and read samples of refused requests.

How reliably a model does what the prompt asks, including format, length and constraints.

Why it matters: When a model ignores a rule in your prompt, test other models before you blame the wording. Instruction following varies a lot between models.

Tracking each change to a production prompt with a version number, an author and the eval results.

Why it matters: Prompts change behavior as much as code does. Without versions, you can't explain why quality dropped last Tuesday.

A shared, organized collection of tested prompts that a team or company reuses.

Why it matters: For internal AI adoption, a prompt library is often the first useful artifact. For products, it becomes the home for your templates.

The earlier messages in a chat that get sent back to the model with each new turn so it keeps context.

Why it matters: Long histories raise cost and can confuse the model. Decide how much history to keep, and when to summarize it.

Information an assistant stores across sessions, such as user preferences or past projects, and brings back into later conversations.

Why it matters: Memory makes assistants feel personal, but it raises privacy questions. Users need to see, edit and delete what the product remembers.

The tendency of LLMs to use information at the start and end of a long context better than information buried in the middle.

Why it matters: If a key rule or document sits in the middle of a huge prompt, it may get ignored. Put critical instructions where the model attends best, then test it.

Sending the model's output to the user token by token as it's generated, instead of waiting for the full answer.

Why it matters: Streaming makes a slow answer feel fast. It's one of the cheapest perceived speed wins in any chat feature.

Tokens a reasoning model spends working through a problem before its final answer. Many APIs let you set how much reasoning effort to allow.

Why it matters: Thinking tokens are usually billed like output tokens. Raise the effort only on requests where accuracy pays for the extra cost and wait.

Input tokens are what you send to the model. Output tokens are what it generates. Providers usually charge more per output token.

Why it matters: Cost estimates must split the two. A feature that reads long documents and writes short answers has a very different bill from one that writes long reports.

An exchange with several back-and-forth messages, as opposed to one prompt and one answer.

Why it matters: Multi-turn quality is harder to test. Build eval cases that span several turns, including users who change their minds halfway.

The examples a model learns from during training.

Why it matters: Gaps in training data become gaps in product quality. If a model rarely saw your users' language, dialect or domain, expect weaker answers there.

Examples paired with the correct answer, such as emails tagged spam or not spam.

Why it matters: Labeled data is often the scarcest asset in an ML project. Budget for it early.

The work of adding correct answers or tags to raw data, done by people, tools or other models.

Why it matters: Write labeling guidelines the way you'd write a spec. Vague guidelines produce inconsistent labels and a model that learns the inconsistency.

The verified correct answer for an example, used to train or evaluate a model.

Why it matters: Your eval results are only as good as your ground truth. When experts disagree on the right answer, fix the definition before you blame the model.

Data generated by models or simulations instead of collected from real users.

Why it matters: Synthetic data fills gaps fast, especially for rare edge cases, but it inherits the blind spots of whatever generated it. Mix in real examples.

How accurate, complete, current and consistent your data is.

Why it matters: Duplicate, outdated or contradictory documents will surface in answers. When quality drops, audit the data before you swap the model.

The automated steps that collect, clean, transform and deliver data to a model or product.

Why it matters: When an AI feature breaks overnight with no code change, check the pipeline. Upstream data changes are a common silent cause.

The standard language used to query, filter, join and analyze data stored in databases.

Why it matters: AI PMs use SQL to answer their own questions: how many users tried the feature, where they dropped off, which segments got worse answers. Interviewers still test it.

A change over time in the inputs a model sees compared with what it was built and tested on.

Why it matters: Users change, products change and seasons change. Monitor input patterns so you catch drift before the quality complaints do.

When the relationship between inputs and the right answer changes, such as what counts as fraud after criminals change tactics.

Why it matters: Concept drift means yesterday's good model gives today's wrong answers. It's a reason AI features need an owner after launch.

An input variable a traditional ML model uses to make predictions, such as account age or number of past orders.

Why it matters: Not the same as a product feature. When a data scientist says “feature,” check which meaning they intend.

A list of numbers that represents the meaning of text, images or other data in a form computers can compare. Similar meanings get similar embeddings.

Why it matters: Embeddings power semantic search and recommendations, and they catch duplicate content. If retrieval returns the wrong documents, the embedding choice is one of the first suspects.

A list of numbers that represents something, such as the embedding of a sentence. Similar meanings produce vectors that sit close together.

Why it matters: You'll hear “vectorize the docs.” It means converting them into embeddings so they can be searched by meaning.

A database built to store embeddings and search them quickly for the most similar items.

Why it matters: A vector database is infrastructure, not a feature. The product questions are what goes into it, how fresh it stays and who is allowed to retrieve what.

Search that matches meaning instead of exact words, so “cancel my plan” can find an article titled “ending your subscription.”

Why it matters: Semantic search fixes vocabulary mismatch between users and your docs. It can miss exact terms like product codes, which is why hybrid search exists.

Classic search that ranks documents by matching the exact words in a query. BM25 is the most common ranking formula.

Why it matters: Don't throw it away. For names, IDs and error codes, keyword search often beats embeddings.

Combining keyword search and semantic search, then merging the two sets of results.

Why it matters: Hybrid is the default in most production RAG systems because it handles both exact terms and fuzzy questions.

A pattern where an AI system retrieves relevant information from a knowledge base before generating an answer, so the response is grounded in specific documents instead of model memory alone. The pattern was named in a 2020 research paper.

Why it matters: RAG sits behind most company chatbots and knowledge assistants. It keeps answers current without retraining, and it makes answers traceable to sources.

The collection of documents or records an AI system is allowed to retrieve from, such as help articles, policies or product docs.

Why it matters: Content ownership is a PM problem. If nobody owns the knowledge base, the assistant will confidently repeat outdated policies.

Loading documents into a retrieval system: extracting the text, cleaning it, splitting it and indexing it.

Why it matters: PDFs with tables, scanned pages and slide decks often break ingestion. Test your ugliest documents first.

Splitting documents into smaller passages before embedding them, so retrieval can return the relevant part instead of a whole file.

Why it matters: Chunk size shapes answer quality. Chunks that are too small lose context. Chunks that are too large waste tokens and bury the answer.

Organizing embedded chunks and their metadata so they can be searched quickly.

Why it matters: Ask how often the index refreshes. A policy updated today but indexed next week will produce wrong answers all week.

The step where a system finds the most relevant passages for a query before the model answers.

Why it matters: In RAG, retrieval quality caps answer quality. Evaluate retrieval separately from generation so you know which half failed.

The number of passages retrieval returns to the model, such as the top 5 most similar chunks.

Why it matters: More isn't always better. A higher k raises cost and can add noise that distracts the model.

A second pass that reorders retrieved passages with a more precise model before the best ones go to the LLM.

Why it matters: Reranking is a common fix when the right document is retrieved but ranked too low to be used.

Narrowing retrieval using fields like date, region, product or document type.

Why it matters: Filters stop a UK customer from getting the US refund policy. Plan metadata at the same time you plan content.

Retrieval that only returns documents the current user is allowed to see.

Why it matters: Skip this and your internal assistant can leak salary sheets to anyone who asks. It's a launch blocker for enterprise AI.

Having a model rephrase or expand the user's question before retrieval so it finds better matches.

Why it matters: Users write short, vague questions. Rewriting often improves retrieval more than changing the embedding model does.

A structured map of entities and the relationships between them, such as customers, products and orders.

Why it matters: Graphs help when questions depend on relationships, like which enterprise accounts use a feature you plan to retire.

A RAG approach that retrieves from a knowledge graph, or builds one from documents, to answer questions that span many connected facts.

Why it matters: Worth considering when plain RAG fails on “summarize everything about X” questions. It costs more to build and maintain.

How current the data behind an AI answer is.

Why it matters: Show freshness when it matters, like “prices as of this morning.” Stale data presented confidently destroys trust.

Continuing the training of a pre-trained model on more specific data so it performs better on a narrower task, domain, style or behavior.

Why it matters: Fine-tune to change behavior, style or format on a narrow task. Use RAG to add knowledge that changes often. Mixing these two up is a classic interview mistake.

A cheap fine-tuning method that trains a small set of extra weights instead of the whole model, described in a 2021 paper from Microsoft researchers.

Why it matters: LoRA is why fine-tuning is affordable for product teams. It also lets one base model serve several customized versions.

Fine-tuning a model on examples of instructions paired with good responses so it follows requests instead of just continuing text.

Why it matters: This is why modern chat models answer questions rather than rambling on. You benefit from it without ever doing it yourself.

A training method where people rank model outputs and the model learns to prefer the higher-ranked kind. OpenAI's InstructGPT paper made it standard for chat models.

Why it matters: RLHF shapes helpfulness and tone. It also helps explain why models sometimes sound agreeable even when they're unsure.

The problem of making good predictions for new users, items or products that have little or no data yet.

Why it matters: Recommendation and personalization features need a cold start plan, such as asking for preferences at signup or showing popular defaults.

A loop where product usage creates data that improves the model, which improves the product, which attracts more usage.

Why it matters: Everyone claims a flywheel. Interviewers will ask what data you'd capture, how it gets labeled and how it actually reaches the model.

Signals users give without being asked, such as copying an answer, editing a draft or retrying a request. Explicit feedback is the opposite: thumbs, stars and comments.

Why it matters: Implicit signals are more honest and far more plentiful than thumbs up or down. Instrument them from day one, and use explicit feedback mainly to find failure examples.

An AI system that can plan multi-step actions, use tools, observe the results and keep working toward a goal. Agents are more flexible than simple workflows, and they need stronger guardrails and oversight.

Why it matters: Agents are powerful and expensive to get wrong. The PM decides which actions the agent can take alone, which need approval, and how every step gets logged.

A process where an LLM takes several steps, often with tools, to complete a task, with some freedom to decide the next step.

Why it matters: Most “agent” products are agentic workflows on tight rails. That's usually the right call for reliability.

A fixed sequence of model calls and code paths that the team designs in advance. An agent, by contrast, decides its own steps. Anthropic's guide on building effective agents draws this line clearly.

Why it matters: Start with a workflow. Move to an agent only when the task truly needs flexible steps, because agents cost more and fail in less predictable ways.

A model's ability to call external functions or APIs, such as searching a database, sending an email or creating a ticket, by producing a structured request.

Why it matters: Tools turn a chatbot into a product that does things. Every tool is also a permission you're granting, so define what each one may and may not do.

An open standard that lets AI applications connect to tools and data sources through one common interface, instead of a custom integration for each.

Why it matters: MCP makes it faster to plug assistants into calendars, CRMs or code repositories. Security review of each connected server is still your team's job.

The way one piece of software requests data or actions from another. Most teams reach LLMs through a provider's API.

Why it matters: An AI PM should read API docs well enough to know the limits, the pricing and what data gets sent where.

The code layer that coordinates model calls, tools, retrieval and business logic in the right order.

Why it matters: When an AI feature misbehaves, the bug is often in orchestration, not the model. Ask for traces that show each step.

A setup where several specialized agents work together, such as a research agent passing findings to a writing agent.

Why it matters: More agents means more handoffs and more places to fail. Ask whether one agent with good tools would do the job.

An agent's step of breaking a goal into subtasks before acting.

Why it matters: Show the plan to users for high-stakes tasks. A visible plan they can edit catches mistakes before any action runs.

An agent pattern where the model alternates between reasoning and acting, using tools, observing the results and deciding the next step. It comes from a 2022 research paper.

Why it matters: ReAct is the basic loop many agent frameworks use. Knowing it helps you reason about where an agent goes wrong: bad reasoning, the wrong tool or a misread result.

How much an AI system can do without human approval, from suggesting only to acting fully on its own.

Why it matters: Autonomy is a product decision, not a technical one. Match it to the cost of a mistake: draft freely, but move money only with approval.

A design pattern where a human reviews, approves, corrects or escalates AI outputs or actions at important points in the workflow.

Why it matters: HITL is how you ship AI into high-stakes workflows before it's fully trusted. Design the review step so it's fast, or people will rubber-stamp everything.

A pattern where the AI acts on its own while humans monitor it and can step in or reverse actions.

Why it matters: Use it when volume is too high for approvals but mistakes are reversible, like auto-tagging tickets.

A checkpoint where an agent must get human confirmation before taking a sensitive action.

Why it matters: List which actions need a gate before launch: payments, deletions, external emails and anything with legal weight.

Passing a conversation or task from AI to a human, ideally with a summary so the person doesn't start over.

Why it matters: A clean handoff is a feature. Track the escalation rate and whether customers had to repeat themselves.

What the product does when the AI fails, times out or isn't confident, such as showing search results, a default answer or a human contact.

Why it matters: Every AI feature needs a designed fallback, including a plan for when the model provider is down. “Something went wrong” is not a fallback.

The information an agent or app keeps about where a task stands, such as steps done, data collected and decisions made.

Why it matters: Long-running agents need reliable state so they can resume after errors without redoing or duplicating actions.

Agents that operate software through the screen, clicking and typing like a person, instead of through an API.

Why it matters: Useful where no API exists, but slower and more fragile. Treat it as a bridge until a proper integration exists.

An isolated environment where an agent can run code or take actions without touching real systems or data.

Why it matters: Sandboxes let you test risky agent behavior safely. Ask whether the production agent also runs code, and where.

An AI assistant built into a tool that helps a person do their work, with the human staying in control.

Why it matters: Copilot framing sets expectations: it suggests, you decide. That framing lowers the trust bar for launch.

A product designed around AI from the start, where the core experience wouldn't work without it.

Why it matters: AI-native companies often hire core and applied AI PMs and move faster. Interviews there go deeper on evals and model trade-offs.

A product that adds an interface or workflow on top of someone else's model with little technology of its own.

Why it matters: “Wrapper” gets used as an insult, but workflow depth, data and distribution can make a wrapper defensible. Be ready to explain your moat.

A product that combines several components, such as multiple models, retrieval, tools and rules, instead of relying on one model call.

Why it matters: Nearly every serious AI product is a compound system. Quality comes from how the parts fit, which is why PMs must understand the whole chain.

Sending each request to a different model based on its difficulty, cost or type, such as simple questions to a cheap model and hard ones to a strong model.

Why it matters: Routing is one of the biggest cost levers you have. Define what “simple” means using real traffic, then check quality on each route.

The delay between a user request and the product's response. Stronger models, retrieval, long context, tool calls and human review can all make it longer.

Why it matters: Latency shapes whether users wait or leave. Set a latency budget per feature, and know which parts eat it: retrieval, the model, tools or review.

How long before the first part of a streamed answer appears on screen.

Why it matters: For chat, TTFT matters more than total time. Users forgive a long answer that starts fast.

A cap the provider sets on how many requests or tokens you can use per minute or per day. It sets your throughput ceiling.

Why it matters: Hitting rate limits during a launch looks like an outage to users. Check your tier and plan queues or fallbacks before the announcement.

A provider feature that reuses the processed version of a repeated prompt prefix, such as long instructions or a large document, to cut cost and latency.

Why it matters: If every request starts with the same long system prompt, prompt caching can cut your bill noticeably. Ask engineering whether it's switched on.

Processing many requests together in the background instead of one at a time in real time, usually at a lower price.

Why it matters: Anything users don't wait for, like nightly summaries or bulk tagging, is a batch candidate.

Running a model directly on a phone, laptop or other device instead of in the cloud.

Why it matters: On-device wins on privacy, offline use and zero per-call cost. It loses on model size and quality.

What you pay each time a model runs, usually priced per million input and output tokens.

Why it matters: Inference cost scales with usage, so a feature can lose more money the more popular it gets. Model it per user and per task before launch.

The decision to build an AI capability in-house or use a vendor's model, API or product.

Why it matters: Buy for commodity capabilities. Build where the capability is your differentiation or where data can't leave your walls.

Dependence on one provider that makes switching costly.

Why it matters: Keep your prompts and evals portable, and your data too. A clean eval set is what makes switching models a week of work instead of a quarter.

Structured tests that measure whether an AI system produces reliable, useful, safe and high-quality outputs. Evals move teams beyond “this looks good” to quality they can measure again and again.

Why it matters: Evals turn “it seems better” into a number you can defend. Owning the eval definition, meaning what good looks like and which failures are unacceptable, is one of the clearest AI PM responsibilities.

A fixed collection of test inputs with expected outputs or grading criteria, used to score every version of an AI feature.

Why it matters: Build it from real user inputs, include the hard and embarrassing cases, and keep it versioned. It's the most reusable asset your AI team owns.

One input in an eval set, plus what a good response must contain or avoid.

Why it matters: Write test cases from failure reports. Every production bug should become a test case so it can't quietly return.

A written scoring guide that defines what good, acceptable and bad outputs look like for a task.

Why it matters: A rubric is a spec for quality. If two reviewers score the same answer differently, the rubric isn't clear yet.

Using an LLM to grade another model's outputs against a rubric, so you can score thousands of answers quickly. Research on the method found strong judges agree with human raters most of the time, with known biases.

Why it matters: Judges scale your evals, but they tend to favor longer answers and their own style. Check the judge against human ratings before you trust its scores.

People rating AI outputs against a rubric, often domain experts for specialized tasks.

Why it matters: Human review is slow and costly, so spend it where judgment matters most and use it to calibrate your automated judges.

Testing a model or prompt on a fixed dataset before release, without real users.

Why it matters: Offline evals are your release gate. No prompt or model change ships without passing them.

Measuring quality with real users in production, through metrics, feedback and experiments.

Why it matters: Offline tells you it should work. Online tells you it does. You need both.

Reading a sample of failures, grouping them by cause and fixing the biggest groups first.

Why it matters: This is the highest-value habit in AI product work. An afternoon reading a hundred bad outputs beats a week of guessing.

When a change, such as a new model or prompt, makes some outputs worse even if the average improves.

Why it matters: Averages hide regressions. Compare results case by case, and watch your most important user segments.

The share of all predictions a model gets right.

Why it matters: Accuracy misleads when classes are imbalanced. A fraud model that never flags fraud can still be 99 percent accurate.

In classification, the share of predicted positives that were actually positive. It tells you how often the model is right when it says yes.

Why it matters: Push for precision when false alarms are costly, like flagging a real customer's payment as fraud.

In classification, the share of actual positives the model found. It tells you how much the system is missing.

Why it matters: Push for recall when missing a case is costly, like failing to flag a dangerous symptom. Interviewers often ask you to choose between precision and recall for a specific feature.

A single number that balances precision and recall.

Why it matters: F1 is a handy summary, but decisions usually need the separate numbers, because the two kinds of mistakes cost different amounts.

A table showing how many predictions were true positives, false positives, true negatives and false negatives.

Why it matters: Ask for the confusion matrix as well as the accuracy score. The matrix shows which mistakes the model makes.

The model says yes when the answer is no, such as flagging a safe email as spam.

Why it matters: Estimate what each false positive costs: an annoyed user, a support ticket or a lost sale.

The model says no when the answer is yes, such as letting a phishing email into the inbox.

Why it matters: False negatives are often invisible until they cause damage. Find a way to measure what the model missed.

The confidence cutoff above which a model's prediction counts as a yes.

Why it matters: Moving the threshold trades precision for recall. It's a product decision, so own it with data.

A number a model or system gives to show how sure it is about an output.

Why it matters: Use confidence to route work: act automatically when it's high, ask a human when it's low. First check that the scores are calibrated.

How well a model's confidence matches reality. A calibrated model that says 80 percent is right about 80 percent of the time.

Why it matters: LLMs are often poorly calibrated and sound confident when wrong. Don't show confidence numbers to users until you've tested them.

Whether every claim in an answer is supported by the sources the system was given.

Why it matters: Groundedness is the core quality metric for RAG. Measure it separately from whether the answer was helpful.

Whether a response actually addresses the user's question.

Why it matters: An answer can be grounded and still useless. Track relevance next to groundedness.

The share of attempts where the AI completed the user's goal, such as booking the meeting or resolving the ticket.

Why it matters: This is the closest metric to real value for agents and assistants. Define “success” precisely before you measure it.

The share of AI suggestions users accept, such as code completions or draft replies.

Why it matters: A strong signal for copilot features. Pair it with a quality check, because users may accept weak drafts and fix them later.

How much users change AI output before using it, or how often they override the AI's decision.

Why it matters: High edit rates show where the AI is almost useful. Read the edits, because they tell you exactly what users wanted.

The share of AI conversations or tasks handed to a human.

Why it matters: Lower isn't always better. A falling escalation rate with rising complaints means the AI is holding on to cases it should hand off.

The share of support requests resolved by self-service or AI without reaching a human agent.

Why it matters: Leaders love deflection. Pair it with resolution and satisfaction, or you'll end up optimizing for customers who gave up.

The total AI cost to complete one unit of user value, such as one resolved ticket, including tokens, tool calls, retries, and the human review time.

Why it matters: Cost per task beats cost per token for business decisions. It tells you whether the feature can make money at scale.

Comparing two versions of a product, feature or flow with real users to see which one performs better on a chosen metric.

Why it matters: AI outputs vary, so AI experiments need larger samples and a clear primary metric. Test the feature against the non-AI baseline as well as against other prompts.

A test result that is unlikely to be explained by random chance alone, given the sample size and variance.

Why it matters: Don't call an experiment early because the graph looks good. Agree on sample size and duration before launch.

Running a new model or feature on real traffic in the background, without showing its output to users, to compare it with the current system.

Why it matters: Shadow mode is the safest way to test a model swap on real data. Use it before any high-stakes change.

A switch in code that turns a feature on or off for chosen users without a new deployment. Teams use flags for canary releases that start with a small share of users.

Why it matters: Every AI feature should launch behind a flag, so you can turn it off in minutes if it misbehaves.

Tracking how an AI system behaves in production. That covers quality, speed and cost, plus errors, drift and the feedback users send.

Why it matters: Launch is the start of AI quality work. Decide which dashboards and alerts exist before day one.

A detailed record of each step in one AI request: the prompt, retrieved documents, tool calls, outputs and timings.

Why it matters: Traces are how you debug a bad answer. Make sure they're stored, searchable and privacy-safe.

The one metric that best represents the core value a product delivers to users, connecting user value with long-term business health.

Why it matters: For AI features, pick a North Star tied to user value, like tasks completed with AI, rather than raw usage. Usage can climb while the product gets worse.

A metric you watch to make sure improving your main metric doesn't cause harm elsewhere, such as complaint rate or cost per user.

Why it matters: Every AI experiment needs guardrail metrics. Faster answers that double hallucinations aren't a win.

The moment a new user first gets real value from a product, and the rate at which new users reach it.

Why it matters: For AI products, activation often means the first successful AI task. Design onboarding to get users there fast.

The share of users who keep coming back over time.

Why it matters: AI features often get a novelty spike. Retention after the first weeks tells you whether the value is real.

Grouping users by a shared starting point, such as signup week or first AI feature use, and studying how their behavior changes over time.

Why it matters: Compare cohorts before and after an AI launch to see whether new users stick around longer, instead of reading one launch spike.

The sequence of steps users take toward a goal, with the drop-off at each step.

Why it matters: Map where AI enters the funnel. An AI step that adds friction can lower conversion even when its outputs are good.

A growth framework covering Acquisition, Activation, Retention, Referral and Revenue.

Why it matters: A quick way to place an AI feature: is it meant to lift activation, retention or revenue? The answer sets its success metric.

A satisfaction rating, usually from a short survey right after an interaction. Net Promoter Score, a slower relative, asks how likely users are to recommend you.

Why it matters: Track CSAT separately for AI-handled and human-handled conversations. The gap tells you a lot. NPS moves too slowly to judge a single AI feature.

Building AI systems that are fair, safe, transparent, reliable, privacy-aware, accountable and mindful of real-world consequences.

Why it matters: Responsible AI isn't a separate team's job. It shows up in PM decisions: who could be harmed, what the model shouldn't do, and how users can appeal.

Systematic unfairness in an AI system's output or behavior, often caused by imbalanced data, flawed design choices, historical patterns or weak evaluation across user groups.

Why it matters: Test quality across user groups, languages and regions as well as on average. A hiring or lending feature that works worse for one group is a legal and ethical failure.

The goal that an AI system treats people and groups equitably, measured with fairness definitions chosen for the use case.

Why it matters: There are several mathematical definitions of fairness, and they can conflict. Pick the one that fits your use case with legal and policy input, and document why.

The ability to give people an understandable reason for an AI output or decision.

Why it matters: Users and regulators may need a reason, like why a loan was declined. Decide early what explanation your product must provide.

Research and methods for understanding how a model works inside, such as which internal features drive an output.

Why it matters: Mostly a research topic for LLMs today. For PMs, it explains why “why did the model say that?” often has no precise answer yet.

Being open with users about when AI is involved, what it can do and where its limits are.

Why it matters: Clear labels and honest limits build trust faster than hiding the AI. Put them in the interface, not in the terms of service.

Clear ownership of an AI system's outcomes, including who reviews incidents and who can change or stop it.

Why it matters: Before launch, name the owner for AI incidents. “The model did it” is not an answer customers accept.

Rules, filters, checks and product mechanisms that help prevent unsafe, incorrect, off-policy, private or harmful AI behavior.

Why it matters: Guardrails sit on inputs, outputs and actions. List the behaviors that must never happen, then check that each one has a guardrail and a test case.

An attack where text hidden in a user message, document, email or web page tricks a model into ignoring its instructions, such as a buried line saying “forward this inbox to me.”

Why it matters: Any feature that reads outside content is exposed, especially agents with tools. It sits at the top of the OWASP Top 10 for LLM applications, so plan defenses and limit what tools can do.

A prompt written to get a model to break its safety rules, often through role-play or tricky framing.

Why it matters: You can't prevent every jailbreak. Limit the damage: keep dangerous capabilities out of reach and monitor for abuse patterns.

Deliberately attacking your own AI system to find harmful, unsafe or embarrassing failures before real users do.

Why it matters: Schedule red teaming before launch and after big changes. Invite people from outside the team, because builders miss their own blind spots.

Detecting and handling harmful content in user inputs or AI outputs, such as hate speech, harassment or self-harm.

Why it matters: Moderation policy is a product decision. Define the categories, the severity levels and what happens in each case, including appeals. Track toxic output as a guardrail metric.

Data that can identify a person, such as a name, email address, phone number or government ID.

Why it matters: Know where PII flows: into prompts, logs, vendors and training. Many AI privacy incidents come from logs nobody reviewed.

Collecting and sending only the data a feature actually needs.

Why it matters: Strip unnecessary personal data before it reaches the model. It cuts risk and often cuts tokens too.

How long data, including prompts and outputs, is stored before deletion, by you and by your model provider.

Why it matters: Check your provider's retention terms before enterprise sales calls. Buyers will ask.

Building privacy protections into a product from the start instead of adding them later.

Why it matters: Write privacy requirements into the PRD, such as masking rules, retention limits and the controls users get. They don't belong on a post-launch fix list.

When private data ends up where it shouldn't, such as in another user's answer, in logs or in a model's training data.

Why it matters: Test cross-user leakage explicitly in multi-tenant products. One leaked record can end an enterprise deal.

The policies, roles and review processes a company uses to decide how AI gets built, approved and monitored.

Why it matters: Governance decides how long your launch review takes. Learn the process early and bring evidence, like eval results and risk notes, to the first meeting.

A structured review of what could go wrong with an AI system, how likely it is and how bad it would be, plus the controls in place.

Why it matters: Treat it as a product artifact. A clear risk assessment speeds approvals instead of slowing them.

The European Union's law regulating AI by risk level, with strict duties for high-risk uses and transparency rules for things like chatbots and generated content.

Why it matters: If you ship to EU users, know which risk tier your feature falls into. It changes what you must document, test and oversee.

Under the EU AI Act, an AI system used in sensitive areas such as hiring, credit, education or critical infrastructure, which faces strict obligations.

Why it matters: If your feature screens candidates or scores applicants, assume it's high risk until legal says otherwise.

The voluntary framework from the US National Institute of Standards and Technology for managing AI risk, built around four functions: govern, map, measure and manage.

Why it matters: Many enterprise buyers use it as a checklist. Mapping your feature's risks to it makes security and procurement reviews smoother.

Telling users when they're talking to an AI or seeing AI-generated content.

Why it matters: Disclosure is often legally required and always good for trust. Design it into the interface from the first version.

Realistic fake audio, images or video of a real person, created with generative AI.

Why it matters: If your product generates media of people, you need consent rules, abuse reporting and a detection plan.

Embedding signals in AI-generated content, or attaching metadata, so it can later be identified as AI-made.

Why it matters: Provenance is becoming a buyer and regulator expectation for generative media products.

Legal questions about whether training data, prompts or AI outputs infringe someone's rights, and who owns the output.

Why it matters: Know your provider's IP terms and indemnities before you build a content product on them.

People's tendency to trust an automated system too much and stop checking its work.

Why it matters: Human review fails when reviewers rubber-stamp. Add friction to reviews of high-stakes outputs, such as requiring a reason on approval.

Helping users trust an AI exactly as much as it deserves, no more and no less.

Why it matters: Citations, confidence cues and clear limits help users know when to double-check. Over-trust and under-trust both hurt adoption.

A record of what an AI system did, when, with what inputs, and who approved it.

Why it matters: Regulated customers will ask for audit logs. Agents that take actions need them from day one.

A way to disable an AI feature or agent immediately if it causes harm.

Why it matters: Know who can pull it, how fast it works and what users see after. Practice it once before launch.

The EU's General Data Protection Regulation, which governs how the personal data of people in the EU is collected, used and stored.

Why it matters: GDPR rights, like access and deletion, also cover data in prompts and logs, and in memory features.

The Product Manager responsible for deciding what AI-powered products or features to build, how they should behave and how their success will be measured.

Why it matters: The job adds model behavior, data and evaluation to classic PM work. It doesn't replace the classic work.

An AI PM who owns AI features inside a mostly non-AI product, such as an AI assistant inside a SaaS tool or AI recommendations inside a marketplace.

Why it matters: This is the most common AI PM role in 2026 and often the most realistic first target for career switchers.

An AI PM who owns an actual AI model, its training pipeline, its evaluation set and its production behavior. The role is most common at AI-native companies and model labs.

Why it matters: Expect deeper technical interviews on training data, evaluation and model trade-offs. It's often a later-career target.

A Product Manager who uses AI tools to do the job faster, such as synthesizing research, drafting specs or prototyping, without necessarily shipping AI features.

Why it matters: Every PM is becoming AI-enabled. It's a useful starting point, but it isn't the same as owning an AI product.

An entry-level Product Manager role, often designed for new graduates, career switchers or early-career professionals. Some APM programs are rotational and last 12 to 24 months.

Why it matters: APM programs are a strong entry route. They're competitive, so pair applications with portfolio proof.

The core document a Product Manager writes to explain what should be built, why it matters, who it serves, what success means and which risks must be considered.

Why it matters: An AI PRD adds sections a normal PRD skips: example model behavior, eval criteria, failure modes, guardrails, fallback behavior and cost limits.

A short description of a need from the user's point of view, often written as “As a [user], I want [goal] so that [reason].”

Why it matters: For AI features, add what a good output looks like. “Summarize the ticket” isn't testable. Two example summaries are.

The conditions a feature must meet to count as done.

Why it matters: AI acceptance criteria are thresholds, not absolutes. For example: at least [N] percent of eval cases pass, with zero critical safety failures.

The smallest version of a product that tests whether it solves a real problem for real users.

Why it matters: An AI MVP can be surprisingly manual. Humans reviewing every output behind the scenes is a valid way to learn before automating.

An early, rough version built to test an idea, a flow or model behavior before full development.

Why it matters: AI PMs are now expected to prototype. A working prompt demo in an interview or PRD beats three pages of description.

Building software by describing what you want to an AI coding tool and iterating on the result, with little hand-written code.

Why it matters: Great for prototypes and portfolio projects. It's no replacement for engineering review once real users and real data are involved.

Platforms that let you build AI apps, workflows or agents through visual interfaces instead of code.

Why it matters: No-code tools let non-engineers ship real portfolio projects. Hiring managers care more about your decisions than your stack.

The judgment to understand users, identify the right problems and design solutions that create value.

Why it matters: AI product sense adds a layer: knowing when AI is the right tool, where it fails and how to design around that. Almost every AI PM interview loop tests it.

Learning what to build through user research, problem validation and experiments before committing engineering time.

Why it matters: Cheap prototypes make it tempting to skip discovery. Don't. A great model answering the wrong question is still the wrong product.

A framework that looks at the progress a user is trying to make, rather than their demographics or the features they request.

Why it matters: Frame AI features as jobs. “Help me reply to this angry customer fast” guides design better than “add an AI writing assistant.”

A prioritization framework that scores ideas on Reach, Impact, Confidence and Effort.

Why it matters: For AI ideas, confidence and effort are often the most uncertain scores. Run a quick prototype to firm them up before you rank.

A prioritization framework that sorts scope into Must have, Should have, Could have and Won't have.

Why it matters: Useful for scoping an AI MVP. Put guardrails and fallbacks in Must have, not Could have.

A plan showing what a team intends to build and why, usually over the coming quarters.

Why it matters: AI roadmaps need room for uncertainty. Frame items as outcomes and experiments, because model results can change the plan.

The plan for launching and positioning a product, then marketing it, selling it and growing it.

Why it matters: AI GTM also has to set expectations: what the feature does well, where it's weak and when users should double-check it.

Charging customers by how much they use, such as per task, per credit or per seat plus usage.

Why it matters: Because AI has real per-use costs, pricing often has to follow usage. Flat pricing plus heavy users can wipe out your margins.

The revenue and cost of one unit of your business, such as one customer or one task.

Why it matters: AI features add variable costs that classic software didn't have. Know your gross margin per active user before scaling a feature.

A lasting advantage that makes a product hard to copy, such as proprietary data, distribution, workflow depth or brand.

Why it matters: Model access is not a moat, because competitors can call the same API. Interviewers expect you to name a better one.

A situation where improving one part of a product costs you another. AI products trade accuracy against speed, cost against quality, and automation against user control.

Why it matters: Almost every AI interview question is a trade-off question in disguise. Name the options, the cost of each and the one you'd pick for this user.

Keeping leaders, partner teams and customers informed and aligned on product decisions.

Why it matters: AI brings extra nervous stakeholders: legal, security and compliance. Bring them in early with concrete examples and eval results.

The point where a product clearly satisfies strong demand in a market, shown by retention, growth and users who'd be upset to lose it.

Why it matters: AI demos can fake early excitement. Retention and repeat use are the honest signals.

A goal-setting method that pairs a qualitative objective with measurable results.

Why it matters: Write AI key results as outcomes, such as resolution rate, not outputs like “launch the chatbot.”

Software companies use to collect, scan, organize and filter resumes before a recruiter or hiring manager reviews them.

Why it matters: Mirror the job description's exact AI terms on your resume where you truly have the experience. This glossary doubles as a checklist for which terms matter.

A behavioral interview framework: Situation, Task, Action and Result.

Why it matters: For AI PM behavioral questions, make the Result include a metric and what you learned about model behavior.

A product sense interview framework: Comprehend, Identify, Report, Cut, List, Evaluate and Summarize.

Why it matters: Adapt it for AI questions by adding a step: decide whether AI is the right solution and how you'd evaluate it.

A self-directed project that proves you can do the job, documented with the problem, your decisions and the results.

Why it matters: Five focused AI projects with case studies beat a list of certificates. Hiring managers read decisions, not badges.

A written walkthrough of a project: the user, the problem, options considered, decisions, trade-offs, evaluation and outcome.

Why it matters: The case study is what gets read. Lead with the decision you made and why.

A written or build exercise some companies set during interviews, such as a product spec for an AI feature.

Why it matters: Use the vocabulary here correctly and show your eval plan. Weak take-homes usually skip evaluation entirely.