Glossary

Agent: An agent is a program that takes actions on its own to reach a goal, instead of just answering a single question and stopping. It typically works in a loop: it reads the current state, decides what tool or API to call next, executes that step, and checks the result before deciding what to do next. This is what lets an AI assistant book a flight, debug code, or research a topic across multiple steps without a human approving every single one. The tradeoff is control - the more autonomy you give an agent, the more you need guardrails around what it's allowed to touch. Wikipedia →
AGI: AGI, or artificial general intelligence, is the idea of an AI system that can handle essentially any intellectual task a human can, rather than being good at a bounded set of tasks. Whether today's models count is genuinely contested - some researchers argue frontier models already show early forms of AGI, others say they're nowhere close, and the answer shifts with where you set the bar. When you hear AGI in a pitch or a headline, the useful question is what specific capability claim is actually being made. Wikipedia →
AI washing: AI washing is marketing a product as AI-powered when the AI is minimal, incidental, or sometimes not there at all. It ranges from slapping 'AI' on a rules-based feature to pitching a thin wrapper around someone else's model as proprietary technology. The incentive is obvious - AI features get attention, budget, and valuation premiums. When you're evaluating a vendor, the practical test is asking what the model actually does inside the product, and what would be left if the model were removed. Wikipedia →
Alignment: Alignment is the work of getting a model to reliably do what its builders and users actually intend, rather than what a literal reading of its training objective would produce. It covers everything from following instructions and refusing harmful requests to not gaming the metric it's being optimized for. Most of the practical techniques - RLHF, safety fine-tuning, constitutional approaches - are attempts to close the gap between 'what we asked for' and 'what we meant'. For product teams, alignment shows up as how much you can trust a model's default behavior before adding your own guardrails. Wikipedia →
Anthropic: Anthropic is the AI safety company that builds the Claude family of models. It was founded by former OpenAI researchers who wanted to make safety and alignment a first-class part of how frontier models get built, not an afterthought. Beyond Claude itself, Anthropic publishes a lot of its safety and interpretability research openly, and built the Model Context Protocol (MCP) to standardize how models connect to external tools. If you're using Claude Code, Claude.ai, or the Claude API, you're using Anthropic's stack. Company website →
Attention: A mechanism that assigns different weights to parts of an input when building a representation. It helps a model use relevant relationships; it is not human awareness. Company website →
Autoregressive model: An autoregressive model generates text one token at a time, where each new token is predicted from everything written so far - your prompt plus its own previous output. This is the core mechanism behind GPT-style models: there's no separate 'answer step', just next-token prediction repeated until the model stops. It explains a lot of everyday behavior, like why a model can't go back and fix a word it wrote three sentences ago, and why long answers cost more than short ones. Most of the models you interact with today are autoregressive. Wikipedia →

Backpropagation: Backpropagation is the algorithm that makes training a neural network practical: after the network produces a wrong answer, the error is propagated backward through its layers so each internal weight gets nudged in the direction that would have reduced the mistake. Repeating this over millions of examples is how a model gradually learns. You'll never call backpropagation directly, but it's the reason 'training' means something other than hand-writing rules. When someone says a model 'learned' a behavior, backpropagation over data is almost always the mechanism underneath. Wikipedia →
Base model: A base model is the raw pretrained model before any instruction tuning, chat fine-tuning, or safety training is applied. It's extremely good at continuing text, but it doesn't naturally answer questions, follow instructions, or stay within polite boundaries - it just predicts what plausibly comes next. The products you actually use, like Claude or ChatGPT, are base models plus several stages of additional training on top. Knowing the difference matters when a vendor brags about a 'frontier base model': raw capability and usable behavior are two separate things. Wikipedia →
Batch size: Batch size is how many training examples a model processes before updating its internal weights - instead of adjusting after every single example, it averages the error over a small batch. Larger batches make training faster and more stable per step; smaller batches are noisier but sometimes generalize better. It's one of the basic knobs in training or fine-tuning, alongside learning rate and epochs. You'll mostly meet it in fine-tuning UIs and training logs, where it's a standard setting rather than something to overthink. Company website →
Benchmark: A shared test or set of tasks used to compare systems. A benchmark score describes performance on that test, not a promise about every customer workflow. Company website →
Bias: Bias is when a model's outputs skew in a consistent, unwanted direction because of patterns baked into its training data - not because you asked it to. It can show up as favoring certain demographics, languages, or viewpoints over others, often in ways subtle enough to slip past casual testing. Bias gets introduced at multiple points: what data was collected, who labeled it, and what the model was optimized to reward during training. Catching it usually requires deliberately testing edge cases and different user groups, not just checking overall accuracy. Read more →
Black box: A black box system is one where you can see the inputs and the outputs but not the reasoning in between - and modern neural networks are the classic example, because even their builders can't fully explain why a specific input produced a specific output. That creates a practical governance problem: you can measure how often a model is right, but you often can't show why it was wrong in a given case. It's why fields like interpretability exist, and why high-stakes uses lean on testing and monitoring rather than trust. For a PM, 'the model is a black box' is a reason to invest in evaluation, not a reason to avoid shipping. Wikipedia →

Chain of thought: Chain of thought is having a model write out its reasoning step by step before giving a final answer, instead of jumping straight to a conclusion. It tends to produce more reliable results on problems that involve multiple steps of logic, like math word problems or multi-step planning. You can prompt for it explicitly ("think step by step") or a model may do it natively as part of how it's built to respond. The visible reasoning also gives you something to sanity-check - if the steps don't make sense, the final answer probably doesn't either.
ChatGPT: OpenAI's AI assistant product for tasks such as writing, analysis and coding. ChatGPT is the application; GPT names refer to model families that can power products. Company website →
Claude: Anthropic's name for its AI model family and assistant. The chat product and API expose different ways to use those models, so specify which one a requirement refers to. Company website →
Cohere: An AI company focused on enterprise systems, including language models, search and retrieval. It is a model and platform provider, not a single chatbot. Company website →
Computer use: Computer use is giving a model direct control of a screen, mouse, and keyboard so it can operate software the way a person would - clicking buttons, filling forms, moving between apps. It matters because most of the world's software doesn't have an API, so an agent that can drive a screen can reach work that API-only integrations can't. The tradeoff is reliability and safety: screens are ambiguous, UIs change without notice, and a misclick can be a real action in a real account. Anthropic shipped a well-known version of this, and it's a fast-moving area across the industry. Company website →
Confidence interval: An interval produced by a method designed to capture an unknown population quantity at a stated long-run rate. A 95% confidence interval is not a 95% probability that this particular interval contains the true value. Company website →
Confusion matrix: A table comparing predicted classes with actual classes. It shows which types of mistakes a classifier makes instead of hiding them inside one accuracy score. Company website →
Context window: The context window is how much text a model can "see" at once, measured in tokens, including your prompt, any attached documents, and its own reply so far. Once a conversation or document exceeds that limit, the oldest parts start getting pushed out or summarized, and the model effectively "forgets" them. Bigger context windows let you paste in more documents or hold longer conversations without losing earlier details, but they also cost more to run and can slow response times. Knowing your model's context window matters a lot when you're designing anything that processes long documents or multi-turn conversations. Wikipedia →
Correlation: A measure of how variables move together; Pearson correlation measures linear association. Correlation alone does not show that one variable causes the other. Company website →
Cursor: Cursor is an AI-native code editor built as a fork of VS Code, designed around having an AI pair programmer built into the editing experience rather than bolted on as a sidebar. It can read your whole codebase for context, make multi-file edits, and let you chat with an AI about your code directly inline. It's become popular with engineers who want AI assistance woven into their actual workflow instead of copy-pasting between a chatbot and their IDE. Cursor is a strong example of the broader shift toward "agentic" coding tools that can take actions in your codebase, not just suggest text. Company website →

Data drift: Data drift is when the real-world data your model sees in production slowly stops resembling the data it was trained and evaluated on, so performance degrades without anyone changing the model. Customer language shifts, new product lines appear, user behavior changes after a launch - the model stays the same but the world moves. It's one of the main reasons ML features need monitoring after release, not just before. The fix is detecting drift early and refreshing training and eval sets on a schedule, not assuming a launch-day score still holds. Wikipedia →
Databricks: A company whose platform combines data engineering, analytics and AI work. Teams use it to manage the data and systems around models, not only to call a chatbot. Company website →
Dataset: A dataset is the collection of examples a model is trained or fine-tuned on, and it's the raw material everything else depends on. It can be text, images, audio, or structured data, and it needs to be reasonably clean and relevant for the model to learn the right patterns - garbage in, garbage out still applies. Datasets are usually split into training, validation, and test sets so you can check whether the model actually generalizes instead of just memorizing. For fine-tuning a model on your own use case, the quality and size of your dataset usually matters more than which base model you start from. Read more →
Deep learning: Machine learning that uses neural networks with multiple layers to learn representations of data. It is a subset of machine learning, not a synonym for all AI. Company website →
Deepfake: A deepfake is synthetic media - video, audio, or images - where a model fabricates a realistic depiction of a real person saying or doing something they never did. The same generation techniques behind legitimate creative tools make this possible, which is why the line between 'AI-generated content' and 'deepfake' is about consent and deception, not technology. Practical risks include fraud calls that clone an executive's voice and fabricated endorsements. If your product touches user-generated media or identity verification, deepfakes are a threat model to design for, not a curiosity. Wikipedia →
DeepSeek: An AI company that develops language and reasoning models and provides chat and API access. The company name also appears in the names of its models. Company website →
Diffusion model: A diffusion model generates images (and increasingly video and audio) by starting from pure noise and gradually removing it, step by step, until a coherent picture emerges. Training teaches the model what 'slightly less noisy' looks like, so at generation time it can denoise its way from static to a finished image. This is the family of techniques behind tools like Stable Diffusion and DALL-E. It's a different architecture from the autoregressive models that write text, which is why image and text models have such different strengths and failure modes. Wikipedia →
Distillation: Training a model to reproduce useful behavior from another model. It can help create a smaller or cheaper model, but the student still needs its own evaluation. Company website →

Embedding: An embedding is a list of numbers that represents the meaning of a piece of text, image, or other data, so a computer can compare how similar two things are mathematically. Words or phrases with related meanings end up with embeddings that are close together in that numerical space, even if they don't share any letters in common. This is the foundation behind semantic search, recommendation systems, and retrieval-augmented generation (RAG), where you need to find the most relevant documents for a query. Most modern AI products have an embedding step happening somewhere behind the scenes, even if it's invisible to the end user. Read more →
Emergent capabilities: Emergent capabilities are abilities that show up in larger models that smaller versions of the same model simply don't have - sometimes seemingly all at once, past a certain scale. Multi-step arithmetic and some forms of reasoning appeared this way, which is part of why labs keep scaling up. There's active debate about how sudden these jumps really are versus artifacts of how we measure them. Either way, the practical lesson holds: a capability that's absent in this generation of models may be present, unannounced, in the next one. Wikipedia →
Epoch: An epoch is one full pass through the entire training dataset during model training. Training usually takes many epochs - the model sees the same data repeatedly, adjusting a little each time. Too few epochs and the model underfits; too many and it can overfit, memorizing the training data instead of learning general patterns. When you fine-tune a model through a vendor UI, epoch count is one of the few settings you're actually asked to pick. Company website →
Error analysis: Error analysis is the unglamorous practice of actually reading your model's failures, sorting them into buckets, and fixing the biggest bucket first. Instead of chasing one aggregate score, you look at a sample of wrong answers and ask what kind of wrong they are - wrong facts, wrong format, missed instructions, retrieval failures. It turns 'the model feels unreliable' into a prioritized list you can act on. For AI features in production, a standing error-analysis habit beats almost any dashboard. Read more →
Evaluation (eval): A repeatable way to assess model or system behavior against defined criteria. A useful eval tests the work that matters, including failures, rather than only whether an answer sounds good. Company website →

F1 score: The harmonic mean of precision and recall. It combines both into one number, but can hide which kind of error matters more to the product. Company website →
False negative: A positive case the classifier misses, such as a spam email left in the inbox. Missing a rare but serious event may matter more than overall accuracy. Company website →
False positive: A case incorrectly marked as positive, such as a legitimate email flagged as spam. The cost depends on what happens after that label. Company website →
Few-shot prompting: Few-shot prompting is showing a model a handful of examples of what you want - input, then ideal output - directly inside the prompt, so it can pattern-match your intent instead of guessing from instructions alone. It's often the fastest way to get consistent formatting, tone, or classification behavior without any fine-tuning. The catch is that examples eat context window space, and a biased set of examples will bias the output. When instructions alone keep missing, two or three good examples usually beat another paragraph of explanation. Wikipedia →
Fine-tuning: Fine-tuning is continuing to train an already-pretrained model on a smaller, task-specific dataset so it specializes in something - like understanding legal documents or matching a particular tone of voice. It's cheaper and faster than training a model from scratch, since the model already has general language and world knowledge from pretraining. The tradeoff is that fine-tuning bakes new knowledge directly into the model's weights, which makes it harder to update later compared to approaches like RAG that keep knowledge external. It's a good fit when you need consistent behavior on a narrow task, not when the underlying facts change often. Read more →
Foundation model: A foundation model is a large general-purpose model trained on broad data that serves as the starting point for many different products and tasks, rather than being built for one narrow job. The same foundation model can be adapted into a chatbot, a coding assistant, or a search tool with relatively little extra work. The term captures a real shift: capability now concentrates in a small number of these base models, and most AI products are layers on top of them. When you choose a vendor's model, you're choosing which foundation your product stands on. Wikipedia →
Frontier model: A frontier model is whichever handful of models sit at the current edge of capability at a given moment - today that means the flagship releases from OpenAI, Anthropic, Google, and a few others. The label is time-bound by definition: last year's frontier model is this year's mid-tier. It matters practically because frontier models cost the most and set the ceiling on what your AI feature can do, while older, smaller models set the floor on what it costs to run. Pick per task, not per hype. Read more →

Gemini: Google's name for an AI model family and its assistant product. A feature available in the app is not automatically available through every Gemini API or model. Company website →
Gemini 4 Carbon: Gemini 4 Carbon is Google's newest frontier model, announced in late October 2026. It's built for coding and long-horizon agentic work - multi-step engineering tasks where the model has to hold a plan together for hours, not minutes. Google is emphasizing its cybersecurity capabilities, like finding and patching vulnerabilities in code. Access is limited for now: vetted cyber defenders first through Google's Fairwind Program, with broader availability planned later. Company website →
Gemini Notebook (formerly NotebookLM): Google's research and learning product for working with sources and turning them into useful explanations and other formats. It was renamed from NotebookLM; source-grounded answers still need checking. Company website →
Generative AI: Generative AI is any AI that produces new content - text, images, code, audio, video - rather than just classifying or scoring existing content. The term took off because it marked the shift from AI that labels things (spam or not, churn risk high or low) to AI that makes things. Most of what people mean by 'AI' in conversation today is generative AI. For a PM, the distinction matters because generation features fail differently than classification features: they can be fluent, plausible, and wrong all at once. Wikipedia →
Genie 4: Genie 4 is Google DeepMind's newest world model - it generates interactive, real-time simulations you can steer with natural language, now with sound, music, and dialogue alongside the visuals. You set an event in motion and it simulates what happens next: how the scene responds, how it sounds, how the people in it move and react. DeepMind points to training and testing environments for robots and agents as a use case - variable scenarios without building each one by hand. Access is a limited research preview for now. Worth remembering: an agent tested inside a generated world is only as trustworthy as the world generator. Company website →
Google DeepMind: Google's AI research organization, developing models and systems across language, science, robotics and other fields. It is the organization, not the Gemini app. Company website →
GPU: A GPU, or graphics processing unit, is a chip built to run thousands of simple calculations in parallel - originally for rendering graphics, which turned out to be exactly the math neural network training needs. That's why NVIDIA became the most important hardware company in AI: modern model training is essentially a GPU-count competition. For most product teams this stays behind the scenes, but it surfaces as cost (GPUs are expensive), availability (scarcity moves cloud pricing), and latency (bigger models need more of them). When someone says 'compute', they usually mean GPUs. Wikipedia →
Grounding: Grounding is anchoring a model's answers in actual sources - documents, search results, your own data - instead of letting it answer purely from patterns in its training. A grounded answer can cite where it came from; an ungrounded one is the model's best guess, however confident it sounds. RAG is the most common grounding technique. If users will make real decisions from your AI feature's answers, grounding is the difference between a claim they can check and one they have to trust. Company website →
Guardrails: Guardrails are rules or checks layered around a model to keep its outputs within bounds you've defined - blocking certain topics, filtering unsafe content, or catching outputs that don't match an expected format. They sit outside the model itself, so you can update or tighten them without retraining anything. Common examples include content moderation filters, output validators that check a response matches a schema, and rate limits on what actions an agent is allowed to take. Guardrails don't make a model perfect, but they reduce the blast radius when it gets something wrong. Wikipedia →

Hallucination: A hallucination is when a model states something false with total confidence, because it's predicting plausible-sounding text, not actually looking anything up or checking facts. It can look completely convincing - a fake citation, a made-up API method, a confidently wrong date - which is what makes it dangerous in production settings. Hallucinations tend to get worse when a question falls outside what the model was trained on, or when it's pushed to answer something it doesn't actually know. Techniques like RAG, better prompting, and human review all help reduce it, but none of them eliminate it completely. Wikipedia →
Harness: A harness is everything around the model that turns it from a text generator into a working system - the code that feeds it prompts, gives it tools, checks its outputs, retries failures, and decides when to stop. Two products can use the exact same model and behave completely differently because their harnesses differ. When an AI feature misbehaves, the bug is as often in the harness as in the model: wrong context, wrong tool wiring, no recovery check. Debugging starts by figuring out which layer failed. Read more →
Hugging Face: Hugging Face is a platform and community best known for hosting open-source AI models, datasets, and tools, often described as "the GitHub of machine learning." Its Transformers library made it dramatically easier for developers to download and use pretrained models instead of training everything from scratch. Beyond hosting, Hugging Face also provides infrastructure for running and fine-tuning models, and has become a default reference point for tracking what open-source models exist and how they perform. If you've ever used an openly available AI model rather than a closed, proprietary one, there's a good chance you found it through Hugging Face. Company website →
Human-in-the-loop: Human-in-the-loop is designing a workflow so a person reviews, approves, or corrects the AI's output at specific steps, rather than letting it run fully autonomously. It's the standard pattern for high-stakes actions: the model drafts, a human approves, the system executes. The tradeoff is throughput - every human checkpoint adds latency and cost, so the design question is which steps genuinely need one. A good rule: the harder an action is to undo, the more it deserves a human in the loop. Wikipedia →
Hyperparameter: A hyperparameter is a setting you choose before training starts - things like learning rate, batch size, or number of epochs - as opposed to the weights, which the model learns on its own. Getting them right is mostly educated trial and error, which is why training involves so many experimental runs. For fine-tuning through a vendor, you usually touch only a few of these and the defaults are reasonable. The term comes up most in incident reviews: 'we changed a hyperparameter' is a complete explanation for a behavior shift. Company website →

In-context learning: In-context learning is a model's ability to pick up a task just from what's in the prompt - instructions, examples, retrieved documents - without any change to its weights. It's why you can paste in a style guide and get on-style output seconds later, no training run required. The catch is that this 'learning' is temporary: it lasts only as long as the conversation, and it competes for space in the context window. Fine-tuning changes the model; in-context learning changes the conversation. Wikipedia →
Inference: Inference is the stage where a trained model is actually put to work - generating a chatbot's reply, classifying an image, or producing any real output from a live input. It's distinct from training: training is where the model learns, inference is where it applies what it learned. In production, inference needs to be fast, reliable, and able to handle many requests at once, which is a very different engineering problem than training a model in the first place. Most of the cost and latency users actually experience with AI products comes from inference, not training. Read more →
Instruction tuning: Instruction tuning is fine-tuning a base model on a large set of tasks phrased as instructions with good responses, so it learns to actually do what people ask instead of just continuing text. It's the main step that turns a raw base model into something you can hold a conversation with, and most helpful-and-harmless behavior gets layered on during or after this stage. When a model follows your formatting instructions reliably, you're benefiting from instruction tuning. It's also why the same base model can become very different products in different hands. Wikipedia →
Interpretability: Interpretability is the research effort to understand what's happening inside a model - which internal features represent which concepts, and why a given input produced a given output. It matters because these models are grown, not written: nobody hand-coded their behavior, so explaining a specific decision after the fact is genuinely hard. Real progress here would make auditing, debugging, and regulating AI much easier. For now, treat interpretability as an active research frontier, not a tool you can buy. Company website →

Jailbreak: A jailbreak is a prompt specifically crafted to trick a model into ignoring its own safety rules and producing content it would normally refuse. Common techniques include role-play framing ("pretend you're an AI with no restrictions"), splitting a harmful request across multiple steps, or burying it inside seemingly innocent instructions. Model providers are in a constant back-and-forth with people finding new jailbreak techniques and patching against them. If you're building on top of a model, it's worth assuming some jailbreak attempts will get through and designing your own guardrails accordingly. Wikipedia →
Jev: Jev is a model from TypeSafe AI that makes fast, structured decisions instead of generating text - you send it a state and questions about that state, and it returns typed answers with probabilities (yes/no, multiple choice, or scored ratings). TypeSafe calls this class a System One model: think classifier, not chatbot. It fits the spots in an agent loop where you'd otherwise burn a full LLM call on a simple decision - routing a request to the right model, flagging a risky tool call, triaging messages. The company claims up to 200x faster inference and 400x lower cost than comparable LLMs on classification tasks, which is vendor math, but the use case is real. It's not a replacement for an LLM - it handles the judgment calls between the generation steps. LangChain blog →
JSON mode: JSON mode is a model setting that forces the output to be valid JSON, so your code can parse the response without praying over a regex. Instead of asking nicely for structured data and hoping, the model is constrained to produce syntactically valid JSON every time. It doesn't guarantee the content is correct - just that the format is parseable. If you're building anything that pipes model output into another system, JSON mode or a structured-outputs feature is the sane default. Company website →

Keras: Keras is a high-level, open-source deep learning library that makes it easier to build and train neural networks without writing low-level math from scratch. It's designed to be readable and beginner-friendly, letting you describe a network layer by layer in just a few lines of code. It runs on top of lower-level frameworks like TensorFlow, handling the complex numerical machinery underneath while you focus on model design. It's often the first tool people reach for when learning deep learning, before graduating to more hands-on frameworks. Wikipedia →
Knowledge cutoff: A knowledge cutoff is the date after which a model knows nothing from its training data - events, releases, and changes after that date simply don't exist for it unless you supply them. It's why a model can describe a library's old API with total confidence while the new version broke that API months ago. You can work around a cutoff with RAG or by pasting current information into the prompt, but the model won't know it needs the help. Always check the cutoff before trusting a model on anything recent. Wikipedia →
Knowledge graph: A knowledge graph is a structured store of facts as entities and relationships - 'Paris is-capital-of France' - that systems can query precisely instead of guessing from prose. In AI stacks, knowledge graphs ground models in verified facts and make retrieval more precise than raw text search. Google Search has used one for years to answer fact questions directly. If your product is full of interconnected entities - people, accounts, assets - a knowledge graph is one of the cleaner ways to make an AI feature accurate about them. Wikipedia →

LangChain: LangChain is a popular open-source framework that gives developers pre-built pieces for common LLM application patterns - chaining prompts, calling tools, loading documents, managing memory. It sped up early AI prototyping enormously, though many teams later strip back to simpler custom code as their needs settle. Its companion, LangGraph, is aimed at more structured agent workflows. You'll hear it mostly from engineers: 'we built it on LangChain' tells you about the stack, not the quality. Company website →
Latency: Latency is how long you wait between sending a prompt and getting a response back, and it matters a lot more in production than it does when you're testing in a chat window. It's affected by model size, how much text you're generating, server load, and network overhead, and it compounds fast in agentic workflows that make several model calls per task. Streaming responses token-by-token instead of waiting for the full answer is one common way to make latency feel less painful, even if the total time is the same. If you're building something interactive, latency budget is worth designing around from day one, not fixing after launch.
Llama: Llama is Meta's family of open-weight models - downloadable models you can run, inspect, and fine-tune yourself instead of renting through an API. That openness made Llama the default starting point for a huge share of self-hosted and research AI work, and entire ecosystems of fine-tunes and tooling have grown around it. The tradeoff versus hosted models like Claude or GPT is operational burden: you control everything, and you maintain everything. If a vendor says 'we run our own models', there's a decent chance a Llama derivative is underneath. Company website →
LLM: LLM stands for large language model - the category that Claude, GPT, and similar text-predicting models belong to. They're trained on huge amounts of text to predict what comes next, and that simple objective turns out to be enough to produce something that can answer questions, write code, and hold a conversation. "Large" refers to both the size of the training data and the number of parameters in the model, though bigger isn't always better for every use case. Nearly every AI product you interact with today - chatbots, coding assistants, writing tools - has an LLM doing the heavy lifting underneath. Read more →
LLM-as-a-judge: LLM-as-a-judge is using one model to score another model's outputs, so you can evaluate quality at a scale human review can't reach. It's the standard workaround when 'correct' is fuzzy - tone, helpfulness, instruction-following - because you can't write a unit test for a good answer. The obvious risk is circularity: the judge has its own biases and blind spots, so its scores need occasional calibration against human review. Used carefully, it turns vibes-based quality checks into something closer to a measurement. Read more →
LoRA: LoRA, or low-rank adaptation, is a fine-tuning technique that trains a small set of extra weights instead of updating the whole model, cutting the cost of customization by orders of magnitude. The result is a small 'adapter' file you can swap in and out, so one base model can wear many different specializations. It's a big part of why fine-tuning is accessible to small teams now instead of just labs with giant GPU budgets. Most vendor fine-tuning offerings and open-source custom models use LoRA or a close relative under the hood. Company website →

Machine learning (ML): Methods that learn patterns from data to make predictions or decisions. The learned behavior depends on the examples and objectives used in training. Company website →
MCP: MCP, or Model Context Protocol, is a standard way to connect a model to external tools, files, and data sources, so it doesn't just rely on what it learned during training. Instead of every developer building a custom, one-off integration between their model and their tools, MCP gives everyone a shared protocol to build against. It was introduced by Anthropic and has since been adopted more broadly across the industry. If you've connected Claude to something like a database, a file system, or an internal company tool, there's a good chance MCP is what made that possible. Wikipedia →
Mean: The sum of the values divided by their count: the arithmetic average. A few extreme values can move it substantially, so compare it with the median. Company website →
Median: The middle value after sorting the data; with an even count, the average of the two middle values. It is less sensitive to extreme values than the mean. Company website →
Mistral AI: An AI company that builds models, developer tools and applications. Check the license of the specific model: a company offering open models does not make every product open-source. Company website →
Mixture of experts: Mixture of experts, or MoE, is a model architecture where only a subset of the model's parameters - the relevant 'experts' - activates for each token, instead of the entire model firing every time. You get the capacity of a huge model at a fraction of the compute per request, which is why many recent flagship models use it. The complexity cost shows up in training and serving rather than in your bill directly. When a model is described as '37B active out of 300B total', that's MoE. Wikipedia →
Model weights: Model weights are the learned numbers inside a neural network - the actual thing training produces, and the actual thing you download when a model is 'open-weight'. Everything a model knows is encoded in these numbers, which is why weight files are treated as crown jewels: whoever has the weights has the model. 'Open' versus 'closed' models is fundamentally about whether the weights are downloadable. Size labels like '70B' refer to the count of these weights. Company website →
Multimodal model: A model that works with more than one kind of data, such as text, images or audio. Check which input and output types the specific model supports. Company website →

Neural network: A neural network is a model loosely inspired by the brain, made of layers of connected nodes ('neurons') that pass signals to each other through weighted connections. Each layer transforms its input a little more, letting the network build up from simple patterns to increasingly complex ones as data flows through it. Modern LLMs, image recognizers, and most of what people call 'deep learning' are all built on top of neural networks at their core. Training one means gradually adjusting those connection weights until the network's outputs match what you want closely enough. Wikipedia →
Next-token prediction: Next-token prediction is the single task language models are trained on: given all the text so far, guess the next piece of text. Everything else - conversation, coding, reasoning - emerges from doing this one thing extremely well at scale. Understanding this deflates a lot of the magic: the model isn't 'deciding to help you', it's continuing a pattern that helpful-looking text usually follows. It's also why prompts matter so much - the prompt is literally the only thing the model has to predict from. Wikipedia →
NLP: NLP, or natural language processing, is the umbrella field of getting computers to work with human language - older than today's LLMs and broader than them. Classic NLP gave us spam filters, translation, and autocomplete using statistical and rule-based methods; modern NLP is largely dominated by large language models. You'll still see the term in job postings, course catalogs, and academic contexts. If LLMs are the engine, NLP is the whole discipline they belong to. Wikipedia →
Non-determinism: Non-determinism means the same input can produce different outputs on different runs - which is the default behavior of generative models, by design. Sampling randomness (temperature), provider version updates, and even hardware-level variation all contribute. It's why you can't unit-test an LLM feature the way you test ordinary code, and why evals measure distributions instead of exact matches. If reproducibility matters - audits, debugging, regulated flows - pin model versions and lower the temperature before blaming the model. Company website →
NVIDIA: A computing company that supplies chips, systems and software used to train and run AI. Its role includes the infrastructure beneath an AI product, not only the model. Company website →

One-shot prompting: One-shot prompting is giving the model exactly one example of the task before asking it to do yours - halfway between zero-shot (no examples) and few-shot (several). One good example is often enough to pin down format and tone when instructions alone are ambiguous. It's cheap in context space and quick to write, which makes it the pragmatic default for many tasks. If one example doesn't fix the output, the next move is a couple more examples, not a longer instruction paragraph. Wikipedia →
Open-weight model: An open-weight model is one whose trained weights are publicly downloadable, so anyone can run, inspect, and modify it - Llama, Mistral's models, and DeepSeek are the standard examples. 'Open-weight' is deliberately not 'open source': the training data and full recipe usually stay private, and licenses vary a lot. The practical upside is control - self-hosting, fine-tuning, no vendor lock-in; the cost is running serious infrastructure yourself. Most 'we trained our own model' startups are actually standing on open weights. Wikipedia →
OpenAI: OpenAI is the AI research company and product maker behind the GPT model family and ChatGPT, one of the products most responsible for bringing generative AI into mainstream use. Beyond ChatGPT, OpenAI provides the GPT API that a huge share of AI products - from customer service bots to coding assistants - are built on top of. The company has shifted over the years from a nonprofit research lab to a much more commercially-oriented product company, which has been a point of ongoing debate in the AI community. If a product you're using says it's "powered by GPT," it's running on OpenAI's models. Company website →
Orchestration: Orchestration is the layer that coordinates multi-step AI work - deciding which model or tool runs when, passing results between steps, handling failures and retries. As products move from single prompts to agentic workflows, orchestration is where most of the engineering actually lives. Frameworks like LangGraph sit in this layer, but plain custom code works too. If the model is the employee, orchestration is the manager assigning the work and checking it. Company website →
Overfitting: Overfitting is when a model memorizes its training data - including its quirks and noise - so precisely that it fails to generalize to new, unseen data. It shows great performance on the exact examples it was trained on, and then disappoints in the real world. It's usually caused by training too long, on too little data, or on a model that's more complex than the problem needs. The fix is typically more or better data, regularization techniques, or stopping training earlier - which is exactly what a held-out validation set is there to help you catch. Read more →

p-value: Assuming a specified null hypothesis and statistical model, the probability of results at least as extreme as those observed. It is not the probability that the hypothesis is true or a measure of practical importance. Company website →
Parameter: A parameter is one of the adjustable numbers inside a model that training tunes - collectively the model's learned knowledge, and the unit behind size labels like '8B' or '70B' (billions of parameters). More parameters generally mean more capacity, though architecture, data, and training quality matter as much as raw count. Parameter count is also a rough proxy for hardware appetite: bigger numbers need bigger GPUs. When comparing models, treat parameter count as a spec-sheet detail, not a quality score. Company website →
Perplexity: Perplexity is an AI-powered answer engine that combines a language model with real-time web search, so its answers come with citations back to the actual sources it pulled from. It's positioned as an alternative to traditional search engines for people who want a direct answer with sources, rather than a list of links to click through themselves. The citation-first approach is meant to directly address the hallucination problem that plain chatbots run into when asked about current events. It's used both as a consumer product and, increasingly, as an API that other products build search-backed answers on top of. Company website →
Pre-training: Pre-training is the long, expensive first phase where a model learns general language and world knowledge from a massive dataset - essentially its entire education before anyone teaches it manners. For frontier models this phase costs enormous amounts of compute, and it produces the base model. Everything later - instruction tuning, RLHF, your fine-tune - is a small adjustment on top of that foundation. It's why you shouldn't expect a light fine-tune to teach a model a field it knows nothing about. Wikipedia →
Precision: Of the cases a classifier marked positive, the fraction that really were positive. For a spam filter, it asks how many messages flagged as spam actually were spam. Company website →
Probability: A number from 0 to 1 describing how likely an event is under a model or set of assumptions. A model-generated confidence score is not automatically a reliable probability. Company website →
Prompt engineering: Prompt engineering is writing and iterating on your instructions to a model to reliably get the output you want, rather than accepting whatever the first attempt produces. It includes things like giving clear examples, specifying the format you want back, and breaking a complex ask into smaller steps. Good prompt engineering can noticeably improve results without touching the model itself, which makes it one of the highest-leverage skills for anyone building with AI. It's also a moving target - what worked well on one model version doesn't always transfer cleanly to the next. Read more →
Prompt injection: An attempt to make an AI system treat untrusted content as instructions. For example, a retrieved page might try to redirect the task or cause private data to be shared. Company website →
PyTorch: An open-source framework for building, training and running machine-learning models. It is a developer tool, not a ready-made model or consumer assistant. Company website →

Quantization: Quantization is shrinking a model by representing its internal numbers with less precision, trading a small amount of accuracy for a large reduction in memory use and a real speed boost. A model quantized from 16-bit to 4-bit numbers, for example, can run on much cheaper hardware, or run several times faster on the same hardware. It's one of the main techniques that makes it possible to run large models locally or on edge devices instead of needing a data center. Done well, the accuracy loss is often barely noticeable for most everyday tasks. Wikipedia →

RAG: RAG, or retrieval-augmented generation, is having a model look up relevant documents at the moment you ask a question, then generate its answer using both that retrieved context and what it already knows. It's a popular alternative to fine-tuning when you need a model to answer questions about information that changes often, like internal company documents or recent news. Because the knowledge lives outside the model, you can update it just by changing the underlying documents, no retraining required. The tradeoff is that RAG is only as good as your retrieval step - if it fetches the wrong documents, the answer will be confidently wrong. Read more →
Reasoning model: A reasoning model is trained to spend extra computation working through a problem internally - generating its own step-by-step analysis before answering - instead of responding in one pass. OpenAI's o-series and DeepSeek R1 popularized the category. The payoff is much better performance on math, logic, and multi-step planning; the cost is latency and tokens, since you're paying for all that hidden thinking. Use reasoning models where correctness is worth waiting for, and regular models where speed and cost matter more. Wikipedia →
Recall: Of all the actual positive cases, the fraction the classifier found. For a spam filter, it asks how much of the real spam was caught. Company website →
Reinforcement learning: Learning a policy for choosing actions through rewards from an environment. A reward measures the behavior being encouraged; it does not guarantee the real goal is met. Company website →
Replit: Replit is a browser-based coding platform that lets you write, run, and deploy code entirely in the cloud, with no local setup required. It has leaned heavily into AI over the past few years with "Replit Agent," a feature that can build and deploy a working app from a plain-language description with minimal hands-on coding. That makes it a popular entry point for people without a traditional engineering background who want to build and ship a real app. It's a good example of how AI is lowering the barrier to building software, not just speeding up experienced developers. Company website →
Reranking: Reranking is a second-pass scoring step in retrieval: after a fast search pulls a hundred candidate documents, a reranker reorders them by actual relevance so the best few reach the model. It's one of the highest-leverage improvements in a RAG system, because retrieval quality is usually the bottleneck, not the generator. Many 'the AI gave a wrong answer' bugs are really 'the wrong document got retrieved' bugs. If your feature cites the wrong sources, look at reranking before touching the model. Company website →
RLHF: RLHF, or reinforcement learning from human feedback, is a training stage where human reviewers rate model outputs and the model is tuned to produce more of what people rated well. It's a big part of why chat models feel helpful and refuse obviously harmful requests - those behaviors are trained in, not magic. The catch is that RLHF optimizes for what raters reward, which can slide toward confident, pleasant-sounding answers over correct ones. It's one layer of alignment, not a guarantee. Wikipedia →

Semantic search: Semantic search finds documents by meaning rather than by matching exact keywords - 'how do I cancel' finds the 'refund policy' page even if those words never overlap. It works by comparing embeddings, the numeric representations of text meaning. This is the retrieval half of most RAG systems, and a big upgrade over keyword search for natural-language questions. Its blind spot is precision-critical lookups like exact error codes, where old-fashioned keyword matching still wins - which is why hybrid search exists. Wikipedia →
Standard deviation: A measure of spread in the same units as the original data, calculated as the square root of variance. Higher values mean the observations are more dispersed. Company website →
Structured output: Structured output is constraining a model to respond in a defined schema - fields, types, and formats your code can rely on - instead of freeform prose. It's what turns a chatty model into a dependable component in a pipeline: extracting fields from documents, populating forms, calling tools with valid arguments. Modern APIs enforce this with JSON mode or schema-constrained decoding. Any time model output feeds another system, structured output is the difference between an integration and a prayer. Company website →
Supabase: Supabase is an open-source backend platform that bundles a Postgres database, authentication, file storage, and instant APIs, positioned as an open alternative to Firebase. It's popular for building apps quickly because it removes a lot of the backend plumbing - user logins, database setup, file uploads - that used to take real time to wire up from scratch. It's increasingly paired with AI coding tools and AI app builders, since it gives an AI-generated app a real, working backend without much manual setup. For a small team or solo builder, it's often the fastest path from an idea to an app with real data and real users. Company website →
Supervised fine-tuning (SFT): Supervised fine-tuning is training a model on curated input-output examples so it adopts a specific behavior, format, or domain style - the workhorse technique behind instruction-following models. You show it thousands of 'here's the request, here's the ideal response' pairs and it adjusts toward that pattern. It's cheaper and more predictable than reinforcement approaches, which is why it's usually the first customization step. When a vendor says 'fine-tuned for your industry', SFT is almost always what actually happened. Wikipedia →
Supervised learning: Training a model on examples paired with target answers, such as emails labeled spam or not spam. The target labels define what the model is learning to predict. Company website →
Synthetic data: Synthetic data is training or evaluation data generated by a model instead of collected from the real world - used when real data is scarce, private, or expensive to label. It's how smaller models get taught by bigger ones, and how teams build test sets for edge cases they'd never catch naturally. The risk is self-reinforcement: errors and blind spots in the generator get baked into the student. Good practice is treating synthetic data as a supplement that's spot-checked against reality, not a substitute for it. Wikipedia →
System prompt: A system prompt is the set of instructions given to a model before a conversation starts, usually invisible to the end user, that sets its behavior, tone, and boundaries. It's how a product team turns a general-purpose model into something that behaves like "their" assistant - naming it, giving it a personality, telling it what it should and shouldn't do. Unlike a regular prompt, it typically persists for the whole conversation rather than being a one-off instruction. Getting the system prompt right is often underrated work - a lot of what feels like "the product" is actually just a well-written system prompt sitting on top of a general model.

Temperature: Temperature is a setting that controls how random or predictable a model's word choices are when generating a response. A low temperature makes the model stick closely to the most likely next word, which is safer and more repeatable but can feel dry. A high temperature lets it take more creative risks, which is great for brainstorming but increases the odds of a less coherent or accurate answer. Most applications default to a moderate temperature and only adjust it deliberately - low for factual tasks like code generation, higher for creative writing. Wikipedia →
TensorFlow: An open-source platform for building and deploying machine-learning models. It provides tools for model development and production use rather than one particular AI capability. Company website →
Test-time compute: Test-time compute is spending more computation at the moment of answering - letting the model 'think longer' - rather than only investing compute during training. Reasoning models are the flagship example: the same model gets smarter on hard problems if you let it work through more steps. This gave the field a second scaling lever: when making models bigger gets expensive, making them think longer still helps. For you it shows up as a literal knob in some APIs: more thinking, more tokens, higher cost, better answers. Company website →
Token: A token is the small chunk of text - often part of a word, not a whole word - that a model actually reads and generates one at a time. The sentence "AI is powerful" might get split into tokens like "AI", " is", " power", and "ful", depending on the tokenizer a specific model uses. This matters practically because pricing, context window limits, and even model behavior are usually measured in tokens, not words or characters. As a rough rule of thumb, a token is about four characters of English text, though it varies by language and content. Read more →
Tokenizer: A tokenizer is the component that chops raw text into tokens, the pieces a model actually reads and writes - roughly word-parts, not whole words and not characters. Different models tokenize differently, which is why the same sentence can cost different token counts on different providers. It matters when you're estimating cost or context usage, and when text behaves oddly around code, URLs, or non-English languages. The rule of thumb 'one token is about three-quarters of a word' is only a rule of thumb. Company website →
Tool calling: A model proposes a structured request for an external function, such as a search or database lookup. The surrounding application decides whether to execute it and returns the result. Company website →
Top-p: Top-p, or nucleus sampling, is a decoding setting that limits the model's word choices to the smallest set of likely options covering a chosen probability mass - say the top 90 percent. Below that cutoff, unlikely words simply can't be picked, which trims weird outputs without making the model robotic. It's an alternative lever to temperature, and you generally tune one or the other, not both. Most applications never need to touch it, but it's there when default sampling feels too wild or too tame. Wikipedia →
Training: Adjusting a model's parameters using data and a learning objective. Training changes the model; sending a normal prompt at inference time usually does not. Company website →
Transformer: A neural-network architecture that uses attention to relate information across an input. Many language models use it, but the architecture alone does not determine model quality. Company website →

Underfitting: Underfitting is when a model is too simple, or hasn't trained long enough, to capture the real patterns in the data - the opposite problem from overfitting. It shows up as poor performance even on the training data itself, which is usually the first clue something's wrong before you even test on new data. Common causes include an overly simple model architecture, too few training passes, or features that don't actually carry the signal the model needs. The fix is usually a more capable model, more training, or better input features - roughly the opposite fixes from overfitting. Read more →
Unstructured data: Unstructured data is information that doesn't sit in neat rows and columns - documents, emails, images, chats, PDFs - which is most of what companies actually have. It's historically been hard to use, because databases and BI tools need structure, and that's exactly what LLMs are good at extracting. A huge share of enterprise AI projects is really 'turn unstructured data into something queryable'. If your AI roadmap doesn't touch your unstructured data, it's probably skipping the valuable part. Wikipedia →
Unsupervised learning: Learning structure in data without target labels for each example. Grouping similar customers is one use; the groups still need human interpretation. Company website →

Validation set: A validation set is a slice of labeled data kept aside during development to check how a model is doing while you're still tuning it - separate from the training set it learns from, and from the test set you touch only at the very end. Peeking at the test set too often quietly turns it into training data, which is how teams fool themselves with inflated scores. The same discipline applies to LLM evals: keep a held-out set you don't optimize against. If every dataset is being used to tune, none of them can tell you the truth. Wikipedia →
Variance: A measure of spread based on squared distances from the mean. It is expressed in squared units, which can make it harder to interpret than standard deviation. Company website →
Vector database: A vector database is a database built specifically to store embeddings and quickly find the ones most similar to a given query, out of potentially millions of entries. Traditional databases are great at exact matches - find the row where ID equals 5 - but bad at "find me the documents that mean something similar to this one." Vector databases solve that by indexing embeddings in a way that makes similarity search fast even at scale. They're a core piece of most RAG systems, since that's exactly the "find relevant documents" step RAG depends on. Wikipedia →
Vercel: Vercel is the cloud platform built around Next.js (which it also created and maintains) for deploying and hosting web front ends, with a strong focus on developer experience and fast deploys. You push code, and Vercel builds and deploys it automatically, with preview URLs for every branch - which has made it a default choice for a lot of modern web and AI-product teams. It's also expanded into AI-specific tooling, like the Vercel AI SDK, which makes it easier to build streaming AI chat interfaces into web apps. If you're building a web app quickly with an AI assistant's help, there's a good chance Vercel is where it ends up hosted. Company website →
Vibe coding: Vibe coding is building software by describing what you want to an AI and accepting its output with minimal line-by-line review - steering by feel and results rather than by reading the code. It's remarkably effective for prototypes and personal tools, which is why the term spread so fast. The obvious risk is shipping code nobody fully understands, including security holes and silent breakage. The professional version of the same idea is agentic coding with review gates: same speed, fewer surprises. Wikipedia →
Vision-language model: A vision-language model, or VLM, is a model that understands images and text together - you can show it a screenshot, chart, or photo and ask questions in plain language. This is what powers features like 'read this error dialog', 'describe this whiteboard', or pulling fields out of a scanned form. Most flagship chat models are now VLMs by default. If your product handles documents or screenshots, VLMs are usually the unlock - no custom computer-vision pipeline required. Wikipedia →

Weights & Biases: Weights & Biases, usually called W&B or wandb, is a popular platform for tracking ML experiments - every training run's settings, metrics, and artifacts in one dashboard instead of scattered notebooks and screenshots. It's the answer to 'which of our forty runs produced the model we shipped?' More recently it's expanded into evaluating and monitoring LLM applications. You won't need it for casual AI use, but any team training or seriously evaluating models will bump into it. Company website →
Wispr Flow: Wispr Flow is a voice dictation tool that uses AI to transcribe speech into clean, properly formatted text in real time, across whatever app you're typing into. Unlike older dictation tools, it's built to handle natural, conversational speech - including filler words and self-corrections - and produce text that reads like you wrote it rather than like a raw transcript. It's popular with people who write a lot for a living and want to talk instead of type, from engineers dictating code comments to writers drafting posts. It's part of a broader wave of voice-first AI tools aimed at replacing typing as the default input method. Company website →
World model: A world model is an AI's internal representation of how the world works - objects, physics, cause and effect - that lets it predict what happens next in a situation, rather than just what text comes next. The term is a frontier research bet: many argue that truly capable AI has to learn from video, simulation, or interaction, not text alone. You'll hear it from labs like Meta and startups working on video prediction and robotics. It's more roadmap than product feature today, but it's where a lot of research money is going. Wikipedia →
Wrapper: A wrapper is a product built as a thin layer around someone else's model - your prompts, your UI, their API underneath. 'Just a wrapper' gets used as a dismissal, but wrappers can carry real value: workflow design, domain knowledge, integrations, and distribution are legitimately hard. The fair question is durability: if the underlying model provider ships your feature natively next quarter, what's left? When evaluating an AI product, ask what it adds beyond the API call. Company website →

xAI: xAI is Elon Musk's AI company, best known for building the Grok family of models integrated into X (formerly Twitter). It positions itself as pursuing a more 'truth-seeking' and less filtered approach to AI compared to some competitors, though that framing is itself debated. Grok is trained in part using real-time data from X, which is a somewhat unique data advantage compared to labs without a large social platform of their own. Since launch, xAI has expanded from a chatbot product into a broader frontier model lab competing directly with OpenAI and Anthropic. Company website →
XGBoost: XGBoost is a battle-tested algorithm for structured, spreadsheet-style data - the thing that wins Kaggle competitions and quietly powers a lot of churn, pricing, and risk models in production. Despite the deep-learning hype, gradient-boosted trees like XGBoost often beat neural networks on tabular business data while being cheaper and faster to run. It's not generative AI, and that's the point: not every 'AI' problem needs an LLM. If your data fits in a table, XGBoost belongs on the shortlist. Wikipedia →

YOLO: YOLO, short for 'You Only Look Once,' is a family of object-detection models known for identifying and locating multiple objects in an image in a single pass, rather than scanning it many times. That single-pass design is what made it dramatically faster than earlier detection approaches, fast enough to run in real time on video. It's widely used in applications like self-driving perception systems, security cameras, and robotics, wherever you need to know what's in a frame and where, quickly. Since its original release, YOLO has gone through many community-driven versions, each pushing speed and accuracy further. Wikipedia →

Zero-shot: Zero-shot is asking a model to do a task with no examples in the prompt - just an instruction - and seeing whether it can generalize from what it already learned. It's the opposite of few-shot prompting, where you include a couple of examples to show the model what you want. Modern LLMs are often surprisingly capable zero-shot, which is part of what makes them useful without needing task-specific training for every new request. That said, for tricky or unusual tasks, giving even one or two examples (few-shot) often improves reliability noticeably over zero-shot alone. Read more →