Developers Digest / Glossary
AI & Developer Glossary
342 terms and counting. Written for developers building with AI, not researchers reading papers.
342 Terms25 Letters
Jump to letter
A
Active Parameters
The part of a model's parameters that is actually used to process each token. In a Mixture of Experts model, a router sends each token to only a few experts, so compute per token follows the active count while memory still has to hold every parameter. Mixtral 8x7B, for example, has 47B total parameters but uses only 13B active parameters per token. Names like Qwen3.6-35B-A3B carry both numbers: 35B total and 3B active.
AdamW
A variant of the Adam optimizer that applies weight decay directly to the weights instead of folding it into the gradient as L2 regularization. Loshchilov and Hutter showed that the two are not equivalent for adaptive optimizers like Adam, and that decoupling them improves generalization and makes the best weight decay value far less dependent on the learning rate. AdamW is the default optimizer for most transformer pretraining and fine-tuning, and ships as torch.optim.AdamW in PyTorch.
Adaptive Thinking
A Claude feature where the model decides how much to reason based on task difficulty rather than a fixed thinking budget. Easy prompts get quick answers and hard prompts trigger extended reasoning, with no manual budget_tokens tuning required. Anthropic recommends adaptive thinking plus effort controls for newer models over the older manual thinking-budget patterns.
Agent Fleet
A group of AI agents run together under coordination to work through a large body of tasks, often for hours at a time. Unlike a one-off multi-agent call, a fleet is an ongoing operation with an orchestrator handing out work, workers executing in parallel, and someone watching for failures, refusals, and cost. Fleets became practical once long-horizon models like Fable 5 and cheaper agentic models like Sonnet 5 made sustained autonomous runs affordable.
Agent Framework
A library that supplies the standard building blocks of an agent, such as calling LLMs, defining and parsing tools, chaining calls, and managing state, so you do not write them from scratch. Examples include the Claude Agent SDK, LangGraph, Mastra, and the Strands Agents SDK. Anthropic's guidance is that frameworks speed up the start but add abstraction that can hide the underlying prompts, so begin with direct API calls and make sure you understand the code beneath any framework you adopt.
Agent Handoffs
A multi-agent mechanism where one agent passes control of the conversation to a more specialized agent, rather than calling it as a subroutine. The OpenAI Agents SDK shows handoffs to the model as tools, so a handoff to a Refund Agent appears as a tool named transfer_to_refund_agent. The receiving agent sees the full prior conversation unless an input filter trims it. Handoffs fit triage setups, where a front-line agent decides which specialist should own the rest of the task.
Agent Identity
Agent identity means giving an AI agent its own verifiable identity, so other systems can authenticate it, limit what it is allowed to do, and log its actions separately from the person it acts for. Without one, agents usually borrow a user's credentials or a shared API key. That makes permissions too broad and audit logs unclear. A 2025 OpenID Foundation whitepaper names agent identities and delegated authority as core open problems, building on OAuth-based protocols like MCP.
Agent Memory
The ability of an AI agent to retain information across turns, sessions, or tasks. Short-term memory lives in the current context window. Long-term memory persists across sessions by writing facts to files, databases, or vector stores. Claude Code uses auto memory to remember project details, debugging insights, and user preferences without being told to save them explicitly.
Agent Observability
The practice of instrumenting an AI agent so its behavior can be inspected afterward through traces, metrics, and logs covering every model call, tool call, and decision. Agents are non-deterministic and take multi-step paths. The OpenTelemetry project notes that this makes their telemetry a feedback loop for evaluation as well as a debugging aid. A standard telemetry format, such as the OpenTelemetry GenAI semantic conventions, avoids lock-in to one vendor's tracing tool.
Agent Sandboxing
Agent sandboxing means running an agent's commands inside a boundary enforced by the operating system or a VM. A bad command or a prompt injection can then only reach the files, processes, and network hosts you allowed. Claude Code's built-in Bash sandbox, for example, uses Seatbelt on macOS and bubblewrap on Linux and WSL2, limits writes to the working directory and temp space, and sends network traffic through a proxy that checks a domain allowlist. Because the OS enforces those limits, sandboxed commands can run without per-command approval, but only what the sandbox wraps is covered: in Claude Code, the file tools, MCP servers, and hooks run outside it.
Agent Skills (SKILL.md)
An open standard, originally developed by Anthropic, for packaging reusable agent knowledge as a folder with a SKILL.md file of YAML frontmatter plus markdown instructions. Claude loads a skill only when the task matches or you invoke it with /skill-name, so many skills can be installed while costing almost no tokens until one fires. The format is adopted across tools including Claude Code, GitHub Copilot, Cursor, OpenCode, Codex, and Gemini CLI, with the spec published at agentskills.io.
Agent Swarm
A multi-agent pattern where many lightweight agents work on sub-tasks simultaneously without a central orchestrator. Each agent operates independently on its assigned piece, and results are aggregated when all agents complete. Swarms trade coordination overhead for parallelism, making them effective for tasks that decompose into independent units like testing multiple files, researching multiple topics, or auditing different parts of a codebase.
Agent Trajectory Evaluation
Evaluating the sequence of steps an agent took, including its messages and tool calls, rather than only its final answer. A trajectory can be matched against a reference in strict order, in any order, or as a subset or superset of the expected tool calls, or it can be graded by an LLM judge without a reference. It catches agents that reach a plausible answer through wrong, wasteful, or unsafe actions.
Agentic AI
AI systems that can pursue complex goals over an extended period with limited direct supervision, taking actions rather than only answering questions. OpenAI's governance paper treats agenticness as a spectrum rather than a yes or no label, measured along goal complexity, environmental complexity, adaptability, and independent execution. In practice the term covers coding agents, research agents, and multi-step workflows built on models with tool use.
Agentic Coding
A development workflow where AI agents write, test, and iterate on code autonomously. Instead of suggesting completions, the agent plans multi-step tasks, runs commands, reads errors, and fixes them in a loop until the job is done.
Agentic Loop
The core cycle that powers AI agents: observe the current state, think about what to do next, act by calling a tool or generating output, then repeat. Each iteration feeds the result of the last action back into the model's context so it can decide the next step. This observe-think-act pattern is what separates agents from single-shot prompt-response interactions.
Agentic Workflow
A system where LLMs and tools are orchestrated through predefined code paths, as opposed to an agent that decides its own next steps. Anthropic names five common patterns: prompt chaining, routing, parallelization, orchestrator-workers, and evaluator-optimizer. Workflows trade flexibility for predictability, which makes them the better fit for well-defined tasks that need consistent cost and behavior.
AI Agent
Software that uses a large language model to reason about goals, break them into steps, call external tools, and act on results without human intervention at each step. Agents differ from chatbots because they maintain a plan and execute it across multiple turns.
AI Safety Levels (ASL)
AI Safety Levels are the tiers of safeguards in Anthropic's Responsible Scaling Policy, where each higher level requires stronger deployment and security protections once a model reaches certain capability thresholds. At ASL-2, models are trained to refuse dangerous CBRN requests and weights are defended against opportunistic theft. ASL-3 adds targeted protections against CBRN misuse, including defenses against universal jailbreaks, plus security built to stop sophisticated non-state attackers. Anthropic first turned on ASL-3 protections on May 22, 2025, when it launched Claude Opus 4.
AI Watermarking
A technique that hides a machine-detectable signal inside AI-generated content so the content can later be identified as model output. The best-known text scheme, from Kirchenbauer et al. in 2023, pseudo-randomly marks a set of "green" tokens before each word is generated and nudges sampling toward them. A statistical test over a short span of text then reveals the watermark without access to the model or its API. Heavy paraphrasing or editing can weaken a watermark, so it is often paired with provenance metadata standards like C2PA.
Aider Polyglot
A code editing benchmark from the Aider project built from the 225 hardest Exercism exercises across C++, Go, Java, JavaScript, Python, and Rust. The model edits a source file to pass the exercise's unit tests. If any tests fail, it gets one more attempt after seeing the error output. It replaced Aider's older Python-only benchmark when top scores started to bunch together, and it rewards models that can make correct, well-formed edits to existing code.
AIME (Benchmark)
The American Invitational Mathematics Examination, a 15-question high school math competition run by the Mathematical Association of America that AI labs use as a math reasoning benchmark. Every answer is an integer from 0 to 999, so grading is exact match and needs no judge model. Labs report results on a specific year's exam, such as AIME 2025, because a newer exam is less likely to be in training data. With only 15 questions, one problem moves the score by almost 7 points, so small gaps between models are noise.
ALiBi
ALiBi (Attention with Linear Biases) is a way to give a transformer position information by penalizing attention scores in proportion to the distance between query and key, instead of adding positional embeddings to the token embeddings. Because the bias is a simple per-head linear penalty, a model trained on short sequences can extrapolate to longer ones at inference time. In the original paper, a 1.3B model trained on 1,024-token inputs matched the perplexity of a sinusoidal-embedding model trained on 2,048 tokens while training 11% faster and using 11% less memory.
Alignment
Alignment is the work of making an AI system behave the way its developers and users actually intend. Anthropic's 2021 paper framed an aligned assistant as helpful, honest, and harmless. The InstructGPT paper described base GPT-3 as not aligned with its users because it produced untruthful, toxic, or unhelpful output. In practice, alignment covers training methods such as RLHF and Constitutional AI, plus evaluations that check whether a model follows instructions, tells the truth, and refuses harmful requests.
Ambient Agents
Agents that start from events, such as a new email or a webhook, rather than from a person typing a message, and that can run many tasks at once in the background. LangChain named the pattern in January 2025 and argued that ambient agents should not be fully autonomous. It described three human-in-the-loop patterns: notify (flag something important), question (ask for missing information), and review (approve an action before it happens). Ambient agents overlap with background agents, but what defines them is the event trigger, not where they run.
API Key
A secret string that authenticates your application with an external service. AI providers like OpenAI, Anthropic, and Google issue API keys so your code can send prompts and receive completions programmatically.
ARC-AGI
The Abstraction and Reasoning Corpus for Artificial General Intelligence, a benchmark of visual grid puzzles. Each puzzle shows a few input-output examples, and the solver has to work out the rule and produce the output for a new input. François Chollet introduced it in 2019 to measure skill-acquisition efficiency on novel tasks rather than memorized knowledge, following the principle of easy for humans, hard for AI. The ARC Prize Foundation now maintains newer versions such as ARC-AGI-2, which keeps the same task format with harder tasks.
Assistant Prefill
A technique where you write the start of the model's reply as the final assistant message, and the model continues from that text. It was commonly used to force a format, such as starting with an opening brace to get JSON or with "The answer is (" to get a single letter. Anthropic's docs state prefill is not supported on Claude 4.6 and later models, which return a 400 error, and recommend structured outputs or system prompt instructions instead.
Attention Mechanism
The core technique inside transformers that lets a model weigh the relevance of every token relative to every other token in a sequence. Instead of processing input left-to-right, attention computes relevance scores across all positions at once, allowing the model to focus on the most important parts of the context regardless of distance.
Attention Sinks
Attention sinks are the first few tokens of a sequence, which LLMs learn to send large attention scores to even when those tokens carry no special meaning. The StreamingLLM paper found that plain window attention breaks once the oldest tokens are evicted from the KV cache, and that keeping the KV entries of those initial tokens restores stable output. That trick let models like Llama 2 and Falcon generate over 4 million tokens without fine-tuning.
Auto Memory (Claude Code)
A feature in Claude Code that automatically remembers important information across sessions without explicit user action. When Claude Code discovers something useful during a session - a build command, a debugging insight, a project convention - it can store it in memory files that load automatically in future sessions. Auto memory reduces the need to repeat context and makes the agent smarter over time for your specific project.
Autonomous Coding
Running a coding agent in a mode where it completes entire features without pausing for human approval. The agent reads the codebase, writes code, runs tests, and commits - all from a single prompt.
Autoregressive Model
A model that generates a sequence one element at a time, feeding each output back in as input for the next step. GPT-3 is described in its paper as an autoregressive language model with 175 billion parameters, and the Transformer decoder works the same way. Because tokens are produced in order, generation time grows with output length. Diffusion language models are designed to remove that bottleneck.
B
Background Agents
Coding agents that run asynchronously on remote infrastructure instead of in your local editor session, so you can hand off a task and keep working. Cursor used the name for agents that clone your repository into an isolated cloud VM, work on a separate branch, and push the changes back for review. It has since renamed the feature Cloud Agents. The defining traits are an isolated environment with real build and test tools, no live supervision, and a reviewable branch or pull request at the end.
Backpressure (Agent)
A flow-control mechanism that prevents an agent pipeline from overwhelming downstream systems. When a fast-producing agent generates work faster than a slow-consuming agent can process it, backpressure signals the producer to slow down or queue work. In multi-agent systems, backpressure prevents token budget exhaustion, API rate limit violations, and runaway costs by throttling agent activity based on available capacity.
Backpropagation
The algorithm that computes how much each weight in a neural network contributed to the error, so gradient descent knows how to adjust it. It runs the input forward to get a loss, then applies the chain rule backward from the output layer toward the input, reusing intermediate results so every gradient comes out at a small constant multiple of the forward pass cost. Popularized by Rumelhart, Hinton, and Williams in 1986, it is what loss.backward() does in PyTorch and it underpins the training of every modern LLM.
Base Model
A language model that has only been pretrained to predict the next token on a large text corpus, with no instruction tuning or preference training on top. It has broad knowledge but tends to continue whatever text you give it rather than follow a request, so prompts work best as documents to complete or as few-shot examples. Labs often release a base checkpoint next to a chat version, as Meta did with Llama 2 and Llama 2-Chat, and base models are the usual starting point for fine-tuning and RL.
Batch Inference
Processing multiple prompts or inputs through a model simultaneously rather than one at a time. Batch inference reduces per-request overhead and can significantly lower costs with providers that offer batch pricing (often 50% cheaper than real-time). It is the standard approach for processing large datasets, running evaluations, and executing offline workloads where real-time response is not required.
Beam Search
A decoding strategy that tracks several candidate sequences (beams) at once and returns the one with the highest overall probability. Unlike greedy decoding, it can keep a sequence whose first tokens were less likely if it leads somewhere better. In Hugging Face Transformers you enable it by setting num_beams above 1. It suits input-grounded tasks like translation, captioning, or speech recognition more than open-ended chat, and costs more compute per output.
Benchmark Contamination
Benchmark contamination happens when a model's training data contains the questions or answers from an evaluation benchmark. The score then partly measures memorization instead of real capability. It is usually accidental, because benchmarks published online end up in web-scale pretraining data. Common defenses are private held-out test sets, benchmarks built from problems published after a model's training cutoff, and checks for overlap between training data and test items.
Benchmark Saturation
The point at which top models score so close to a benchmark's ceiling that it can no longer tell them apart. MMLU is the standard example: frontier models passed 90% accuracy, which is why harder sets like Humanity's Last Exam were built. Near the ceiling, the remaining errors are often mislabeled or ambiguous questions rather than real gaps, so a flat leaderboard does not prove progress has stopped. The usual fixes are harder successors, regularly refreshed question pools, and task-based evals tied to real work.
Benchmarks (AI)
Standardized tests that measure model performance on tasks like code generation, math, reasoning, and instruction following. Common benchmarks include SWE-bench, HumanEval, MMLU, and GPQA. They help developers compare models, but real-world performance often differs from benchmark scores.
Berkeley Function Calling Leaderboard (BFCL)
A leaderboard from UC Berkeley's Gorilla project that measures how accurately models call functions, also called tools. It checks calls both by AST matching against the expected function and arguments and by executing them, across simple, multiple, parallel, and multi-turn categories, plus relevance tests that check whether a model correctly declines when no tool fits. The current V4 adds agentic categories such as memory, and BFCL scores are a staple of small and local model releases aimed at agent work.
Best-of-N Sampling
A technique where you generate N candidate answers to the same prompt and keep the one a scorer ranks highest. The scorer can be a trained verifier, a reward model, unit tests, or an LLM judge. OpenAI's GSM8K paper used this pattern, generating many solutions per math problem and selecting the top one by a trained verifier, which substantially improved accuracy. Cost grows linearly with N, so it pays off most when checking an answer is cheaper than producing one.
Build Tools
Software that compiles, bundles, or transforms source code into production-ready output. In the AI dev space, build tools like Turbopack, Vite, and esbuild handle TypeScript compilation, module bundling, and hot reload for the frameworks that power AI applications.
Byte Pair Encoding (BPE)
A tokenization algorithm that builds its vocabulary by starting from single characters (or bytes) and repeatedly merging the most frequent adjacent pair into a new token. In 2015 Sennrich, Haddow and Birch adapted it from a data-compression algorithm so neural translation models could handle rare and unseen words as sequences of subword units. Byte-level versions power the GPT family and most current LLM tokenizers. That is why a common word is usually one token while a rare name splits into several.
C
Chunking
The process of splitting large documents into smaller, overlapping segments for embedding and retrieval in RAG systems. Chunk size and overlap strategy directly affect retrieval quality. Too large and you lose precision. Too small and you lose context. Common strategies include fixed-size chunks (500-1000 tokens), sentence-based splitting, and recursive character splitting that respects document structure like headings and paragraphs.
Claude Max
Anthropic's highest-tier subscription plan for Claude, available at $100/month or $200/month. Max provides significantly higher usage limits than Pro, including extended context windows, more messages per day, and access to the most capable Claude models. The $200/month tier is the standard choice for professional developers using Claude Code heavily, as it removes most practical usage limits for coding workflows.
Chain of Thought (CoT)
A prompting technique where the model is asked to show its step-by-step reasoning before arriving at a final answer. CoT improves accuracy on math, logic, and coding tasks by forcing the model to decompose problems rather than jumping to conclusions. Reasoning models like o1 and o3 use chain-of-thought internally as part of their training.
CLAUDE.md
A markdown file placed in your project root that configures Claude Code's behavior. It defines project rules, coding conventions, file structure, and custom instructions that persist across sessions - acting as a project-specific system prompt for your AI coding agent.
Claude Code
Anthropic's official CLI tool for agentic coding. It runs in your terminal, reads your codebase, edits files, runs commands, and iterates on tasks autonomously. It uses CLAUDE.md for project config and supports sub-agents, hooks, and MCP integrations.
Claude Sonnet 5
Anthropic's mid-tier Claude model released June 30, 2026 and billed as its most agentic Sonnet yet, with stronger tool use and planning that approaches Opus 4.8 on low and medium effort. Its model ID is claude-sonnet-5, priced at an introductory $2 per million input and $10 per million output tokens through August 31, 2026 before standard $3/$15 pricing. It ships with cyber safeguards on by default and a lower rate of undesirable behaviors than Sonnet 4.6.
Credit Metering
Billing model usage against a pool of consumable credits so that programmatic and interactive work draw from separate budgets. Anthropic's June 15, 2026 Agent SDK split is the reference case: Agent SDK calls, claude -p, and CI agent runs draw from a dedicated monthly credit while interactive Claude Code keeps using the normal subscription pool. Metering lets teams see and cap agent spend as distinct lanes instead of hiding it inside one flat subscription.
CLI (Command Line Interface)
A text-based interface for interacting with software by typing commands. Many AI coding tools - Claude Code, Gemini CLI, Codex - run as CLIs because they integrate directly into the developer's terminal workflow alongside git, npm, and other standard tools.
Compact (Claude Code)
A command in Claude Code that compresses the current conversation history to free up context window space. When a session gets long, the context window fills up and the agent may start losing track of earlier information. Running /compact summarizes the conversation so far into a condensed form, preserving key decisions and state while reclaiming tokens for new work. It is essential for long coding sessions.
Constitutional AI
An alignment technique developed by Anthropic where an AI model is trained to follow a set of principles (a constitution) that guide its behavior. Instead of relying solely on human feedback for every edge case, the model uses its own reasoning to evaluate and revise responses against the stated principles. Constitutional AI is a core part of how Claude is trained to be helpful, harmless, and honest.
Context Engineering
The discipline of designing what information goes into a model's context window and how it is structured. Context engineering goes beyond prompt engineering by managing system prompts, retrieved documents, tool results, conversation history, and memory to give the model exactly the right information at the right time. It is the difference between a model that kind of works and one that works reliably.
CUDA
NVIDIA's parallel computing platform that lets software run computations on NVIDIA GPUs. CUDA is the foundation of GPU-accelerated AI inference and training. When you run a local model with Ollama or LM Studio and it uses your NVIDIA GPU, CUDA is doing the heavy lifting. AMD GPUs use ROCm as an alternative, and Apple Silicon uses Metal.
Context Window
The maximum amount of text (measured in tokens) that a model can process in a single request. Larger context windows let agents read more code at once. Modern models range from 128K to over 1M tokens, but effective use of context still matters more than raw size.
C2PA Content Credentials
An open standard from the Coalition for Content Provenance and Authenticity (C2PA) for attaching tamper-evident provenance records to images, video, audio, and documents. Each record is called a manifest, and "Content Credentials" is the consumer-facing name for it. A manifest bundles assertions about how an asset was made or edited, including whether AI generated it, binds them to the file with cryptographic hashes, and signs the claim with the signer's certificate. Unlike a watermark, a manifest is metadata that can be stripped, but any change to the signed content breaks verification.
Catastrophic Forgetting
The tendency of a neural network to lose previously learned skills when it is trained on a new task, because new gradient updates overwrite the same weights the old skills depended on. It is a practical risk in fine-tuning: a model tuned hard on one narrow dataset can get worse at general instruction following or coding. Common mitigations include mixing original data back in, lower learning rates, parameter-efficient methods like LoRA, and Elastic Weight Consolidation, which slows learning on the weights most important to earlier tasks.
Chain-of-Thought Monitoring
Chain-of-thought monitoring uses an automated monitor, often another language model, to read a reasoning model's chain of thought and flag signs that it intends to misbehave, such as reward hacking, sabotage, or deceiving the user. It works because models that reason in natural language often state a plan before they act on it. A July 2025 paper by researchers from OpenAI, Google DeepMind, Anthropic, and other groups called this a new and fragile opportunity for safety. It urged labs to consider how their development choices could make chains of thought harder to monitor.
Chat Completions API
OpenAI's original chat endpoint, POST /chat/completions, which takes an array of role-tagged messages (developer or system, user, assistant, tool) and returns one or more completion choices. The client manages conversation state by resending the message history on every request. Its request shape became a de facto standard that many other providers, gateways, and local inference servers expose as an OpenAI-compatible API. OpenAI still supports it but recommends the Responses API for new projects.
Chat Template
The formatting rule that turns a list of role and content messages into the exact token sequence a chat model was trained on. Models use different control tokens. Mistral wraps user turns in [INST] and [/INST], while Zephyr uses <|user|> and <|assistant|>, and using the wrong format can badly hurt output quality. In Hugging Face Transformers the template ships with the tokenizer and is applied with tokenizer.apply_chat_template. Its add_generation_prompt option appends the tokens that cue the assistant's reply.
Chinchilla Scaling
The finding from DeepMind's 2022 Chinchilla paper that, for a fixed compute budget, model size and training tokens should grow in equal proportion: double the parameters, double the data. By training over 400 models, the authors concluded that large models of the time were significantly undertrained. Their 70B Chinchilla model, trained on about 4x more data than the 280B Gopher with the same compute, outperformed it and was cheaper to run. The rule of thumb that falls out is roughly 20 training tokens per parameter.
Chunked Prefill
A scheduling technique that splits a long prompt's prefill into equal-sized chunks and processes them over several iterations instead of in one pass. Each batch pairs one prefill chunk with many in-progress decode steps, so the chunk saturates compute while the decodes ride along cheaply. Introduced in the SARATHI paper, it stops long prompts from stalling other users' streams and reduces idle bubbles under pipeline parallelism.
Code Execution Tool
A server-side tool in the Claude API that lets the model run Bash commands and create, view, and edit files inside an Anthropic-hosted sandboxed container. The API executes everything within the same request, so your application never runs code or sends back tool results itself. The container has Python and common command-line tools pre-installed but no internet access, and you pass in your own data through the Files API. It is the usual way to give Claude data analysis, calculations, and file generation without building your own sandbox.
Computer Use
A model capability that lets an AI operate a desktop the way a person does: it looks at screenshots and issues mouse and keyboard actions like click, type, and scroll. With Claude's computer use tool, the model never connects to the machine directly; your application executes each requested action in a VM or container and returns a screenshot or status. The loop repeats until the task is done. Because on-screen content can carry prompt injections, Anthropic recommends isolating the environment from sensitive data and getting user consent.
Confused Deputy
A confused deputy is a program with legitimate authority that gets tricked into using that authority for someone who should not have it. Norm Hardy named the problem in 1988. A compiler had permission to write to its own system directory, and a user gave it the billing file's name as an output path, so it overwrote the billing records. AI agents are textbook confused deputies: they hold the user's credentials and tool access, so an injected instruction can make them act with authority the attacker never had.
Constrained Decoding
A generation technique that restricts which tokens a model may pick at each step so the output is guaranteed to match a format such as a regular expression, a grammar, or a JSON Schema. At every step, tokens that would break the format are masked out before sampling, so invalid output cannot be produced at all. The Outlines paper showed this can be done efficiently by compiling the format into a finite-state machine and indexing the model's vocabulary against it. Provider features like OpenAI Structured Outputs and Claude strict tool use rely on the same idea, often called grammar-constrained sampling.
Context Editing
A beta Claude API feature that automatically clears stale content from a conversation server-side before it reaches the model, while your client keeps the full history. The clear_tool_uses_20250919 strategy replaces the oldest tool results with placeholders once input passes a trigger (100,000 tokens by default) and keeps the three most recent, while clear_thinking_20251015 prunes thinking blocks from earlier turns. It keeps long agent loops under the context limit, though clearing tool results invalidates the prompt cache from that point.
Context Poisoning
A failure mode where a hallucination or error gets written into an agent's context and is then treated as fact on every later turn. Google's Gemini 2.5 technical report used the term for its Pokemon-playing agent, where misinformation about the game state spread into its goals and summary sections, took a long time to undo, and pushed it into misguided strategies. The usual fixes are pruning or resetting the poisoned context and checking facts before an agent writes them into memory or summaries.
Context Recall
A RAG evaluation metric that measures how much of the information needed to answer a question was actually retrieved. Because it is about not missing anything, it always needs a reference: Ragas breaks a reference answer into claims and scores the fraction that can be attributed to the retrieved context, or compares retrieved chunks or document IDs against a labeled set. Low context recall points to a retrieval problem, not a generation problem.
Context Rot
The decline in LLM output quality as the number of input tokens grows, even on simple tasks that fit well inside the context window. Chroma's 2025 report popularized the term after testing 18 models, including GPT-4.1, Claude 4, Gemini 2.5, and Qwen3, and found performance grew less reliable with length, with distractors making it worse. The practical lesson is that a large window is capacity, not a guarantee, so curating what goes into context still matters.
Continued Pretraining
Running more next-token-prediction training on an already pretrained model using a large unlabeled corpus from a target domain, such as code, math, medicine, or a new language. The 2020 paper Don't Stop Pretraining showed that this domain-adaptive second phase improves downstream results, even for strong general models. It sits between pretraining and post-training. For example, DeepSeekMath continued pretraining a coder model on 120B math tokens, and Cursor's Composer 2 came from a continued pretraining run on coding data before RL.
Continuous Batching
A serving technique that schedules work one model iteration at a time, so requests can join or leave a running batch at every token step instead of waiting for the whole batch to finish. It was introduced as iteration-level scheduling in the Orca paper at OSDI 2022, which reported 36.9x higher throughput than NVIDIA FasterTransformer on GPT-3 175B at the same latency. Finished requests return immediately and new ones start without waiting, which is why vLLM, SGLang, and TGI all build on it.
Credential Isolation
Credential isolation keeps secrets such as API keys, SSH keys, and cloud tokens out of reach of the commands an AI agent runs, so a buggy or prompt-injected command cannot read or leak them. Claude Code's sandbox does this with a credentials setting that blocks reads of files like ~/.ssh and ~/.aws/credentials and strips variables like GITHUB_TOKEN from sandboxed commands. Its mask mode goes further: the command only sees a placeholder, and the sandbox proxy swaps in the real value on requests to hosts you allow. There is no built-in deny list, so only the files and variables you list are protected.
Cross-Entropy Loss
The standard loss function for classification and language model training, measuring how much probability the model gave to the correct answer. For an LLM it is the negative log probability of the actual next token, averaged over every position in the training data. In PyTorch, nn.CrossEntropyLoss takes raw unnormalized logits and applies the softmax internally. Perplexity is the exponential of the average cross-entropy, which is why lower loss and lower perplexity mean the same thing.
D
Data Pipeline
A sequence of automated steps that move and transform data from source to destination. In AI applications, data pipelines handle document ingestion, chunking, embedding generation, and vector store population for RAG systems. A well-built pipeline keeps your knowledge base current by processing new documents as they arrive, re-embedding when models change, and cleaning stale data.
Deep Agent
An AI agent that can perform extended, multi-step research or coding tasks by spawning sub-tasks, searching the web, reading documents, and synthesizing findings. Deep agents run for minutes or hours rather than seconds, tackling problems too complex for a single prompt-response cycle.
Delegation Pattern
A multi-agent architecture where a manager agent breaks a task into sub-tasks and assigns each one to a specialized worker agent. The manager coordinates results and handles failures. This pattern is used in Claude Code's sub-agent system (via the Task tool), CrewAI's hierarchical process, and LangGraph's orchestrator nodes. It is the most common way to parallelize agent work.
Diffusion Models
A class of generative models that learn to create data by reversing a gradual noising process. During training, the model learns to remove noise from corrupted data step by step. During generation, it starts from pure random noise and iteratively denoises it into coherent output. Diffusion models power image generators like Stable Diffusion, DALL-E, and Midjourney.
DPO (Direct Preference Optimization)
A training technique that aligns language models with human preferences without needing a separate reward model. Unlike RLHF, which trains a reward model first and then optimizes against it, DPO directly optimizes the language model using pairs of preferred and dispreferred outputs. DPO is simpler to implement, more stable to train, and has become a popular alternative to RLHF for model alignment.
Distillation
A training technique where a smaller "student" model learns to replicate the behavior of a larger "teacher" model. The student is trained on the teacher's outputs rather than raw data, inheriting much of the larger model's capability at a fraction of the size and inference cost. Distillation is how many fast, lightweight models are created from frontier models.
Data Exfiltration (Agents)
Data exfiltration is when an agent is manipulated into sending private data it can reach to a place the attacker controls. Any outbound channel works: an HTTP request to an API, loading an image, or a link for the user to click, which is why Simon Willison counts external communication as one leg of the lethal trifecta. Real incidents have also used commits and public comments. Defenses focus on the channel rather than the prompt: egress allowlists, no automatic rendering of images and links, and keeping secrets out of the agent's environment.
Data Parallelism
A distributed training technique that puts a full copy of the model on every GPU and gives each copy a different slice of the training batch. Each replica computes gradients independently, then the replicas exchange and average those gradients every step so all copies stay identical. It is the simplest way to scale training to more hardware, but it only works when the whole model, its gradients, and optimizer state fit on a single device. PyTorch's DistributedDataParallel adds gradient bucketing and overlaps communication with computation, reaching near-linear scaling on 256 GPUs in the original paper.
Decode Phase
The second phase of LLM inference, where the model generates output tokens one at a time, each step reading the KV cache built so far and adding to it. Because each request contributes only one new token per step, decode leaves GPU compute underused, so servers batch many requests together to keep the hardware busy. Its speed is what users feel as time per output token once a response starts streaming.
Dense Model
A model in which every parameter is used for every token, unlike a sparse Mixture of Experts model that activates only part of the network. Its total and active parameter counts are the same. That makes dense models simpler to train, serve and fine-tune, but they cost more compute per token than an MoE model of the same total size. Meta's Llama 3 405B is a dense Transformer, and the paper says Meta chose that design over MoE to maximize training stability.
Diffusion Language Model
A language model that writes text by starting from a fully masked sequence and filling in many positions in parallel over several denoising steps, instead of producing one token at a time. LLaDA (2025) trained an 8B diffusion model from scratch with a forward masking process and a Transformer that predicts the masked tokens. It was competitive with LLaMA 3 8B on in-context learning. Commercial models like Inception's Mercury drop the left-to-right order to get much higher throughput.
Disaggregated Serving
An LLM serving architecture that runs the prefill and decode phases on separate GPUs and passes the KV cache between them. Running both phases on the same hardware causes interference, where long prefills stall in-progress decodes, and forces one parallelism plan onto two very different workloads. The DistServe paper showed that splitting them lets each pool be sized for its own target, time to first token for prefill and time per output token for decode, serving up to 7.4x more requests within those limits.
Durable Execution
A runtime guarantee that a workflow runs to completion even if the process running it crashes, restarts, or waits for days. Systems like Temporal record each step in an event history. When a worker fails, a new worker replays that history to rebuild the workflow's state and picks up where it stopped. For agents, this means a long run can survive a crash in the middle of a tool call, or pause for human approval, without losing progress or starting over.
E
Extended Thinking
A Claude feature that gives the model a dedicated thinking phase before producing its visible response. During extended thinking, the model works through complex problems step by step internally, similar to chain-of-thought reasoning but happening behind the scenes. Extended thinking improves performance on math, code, and multi-step reasoning tasks. It uses additional tokens but produces more reliable answers for hard problems.
Embeddings
Numerical vector representations of text that capture semantic meaning. Similar concepts have vectors that are close together in high-dimensional space. Embeddings power semantic search, RAG systems, and recommendation engines by letting you find related content without exact keyword matches.
Edge Functions
Serverless functions that run on CDN nodes close to the user rather than in a central data center. Platforms like Vercel and Cloudflare Workers use edge functions to reduce latency for API routes, middleware, and AI inference endpoints.
eve (Vercel Agent Framework)
Vercel's framework for building AI agents where you define an agent as a folder of files - model config, system prompt, and one typed tool per file - and eve compiles it into an app on Vercel Functions. It supplies the production plumbing agents usually hand-roll: durable sessions, a sandbox for code execution, approvals, subagents, and evals. It pairs naturally with long-horizon models like Fable 5 that run long enough to hit crashes, redeploys, and timeouts.
Eval / Evaluation
The systematic process of testing an AI model's performance against a defined set of inputs and expected outputs. Evals measure whether a model is actually good at the task you care about, not just benchmarks. They can be automated (comparing outputs to ground truth) or human-judged (rating quality on a rubric). Running evals before and after changes is how teams catch regressions and validate improvements.
Effective Context Length
The longest input at which a model still performs well, as opposed to the maximum context it will accept. The RULER benchmark (Hsieh et al., 2024) made the gap concrete: of 17 models that all claimed 32K tokens or more, only about half held satisfactory performance at 32K, despite near-perfect scores on simple needle-in-a-haystack retrieval. Treat the advertised window as an upper bound and measure where quality drops on your own tasks.
Emergent Abilities
Capabilities that are absent in smaller language models but appear in larger ones, so they cannot be predicted by extrapolating from small-model performance. Wei et al. coined the term in 2022 to describe tasks where accuracy stays near random until a scale threshold and then jumps. A 2023 follow-up argued many of these jumps come from choosing all-or-nothing metrics, and that smoother metrics show gradual improvement instead.
EU AI Act
The EU AI Act is Regulation (EU) 2024/1689, the European Union's law setting common rules for artificial intelligence, adopted on 13 June 2024. It sorts AI by risk: some practices are banned outright, high-risk systems carry conformity and documentation duties, some systems must meet transparency rules such as labelling AI-generated content, and general-purpose AI models have their own chapter of obligations. As adopted, the bans applied from 2 February 2025, the general-purpose model rules from 2 August 2025, most other provisions from 2 August 2026, and some high-risk rules from 2 August 2027.
Eval Harness
The infrastructure that runs evals end to end: it feeds tasks to the model or agent, records every step, applies graders, and aggregates the results into scores. Anthropic separates it from the agent harness, which is the system that lets the model act; when you evaluate an agent you are measuring the harness and the model together. EleutherAI's open-source lm-evaluation-harness is a well-known example, running over 60 standard academic benchmarks against many model backends.
Eval-Driven Development
A way of building AI systems where you write evals for a capability before the agent can do it, then iterate on prompts, tools, and harness until the evals pass. It is the AI counterpart of test-driven development. Anthropic recommends pairing capability evals, which start at a low pass rate, with regression evals that should stay near 100% so new work does not break old behavior.
Evaluator-Optimizer
An agent workflow where one LLM call writes a response and a second call checks it against explicit criteria and sends back feedback. The two repeat until the output passes or a stop condition is hit. Anthropic lists it as a core agentic workflow and says it works best when the evaluation criteria are clear, as in literary translation where a critic catches nuances the first draft missed. Unlike self-reflection, the critic is a separate prompt or model, and a maximum iteration count stops the loop from running forever.
Expert Parallelism
A distributed training and inference strategy for Mixture of Experts models where different experts live on different GPUs instead of every device holding a full copy. A router picks experts for each token, and an all-to-all collective sends tokens to the devices that host those experts, then gathers the outputs back. Google's GShard paper used this to train a 600B-parameter MoE translation model, noting that experts are too large to replicate so the only viable option is to shard them across devices. Inference engines like vLLM now offer expert parallelism for serving large open-weight MoE models across several GPUs.
F
Fable 5
Anthropic's most capable widely released model, launched June 9, 2026 as the first Mythos-class model available for general use, with a 1M-token context window and up to 128K output tokens at $10 per million input and $50 per million output tokens. Its lead grows the longer and more complex the task, making it a strong driver for long-horizon agent runs. Its model ID is claude-fable-5, thinking is always on, and the effort parameter replaces the old sampling and budget_tokens dials.
Faithfulness (RAG Metric)
A RAG evaluation metric that measures how factually consistent a generated answer is with the retrieved context. Ragas computes it by splitting the answer into individual claims, checking whether each claim can be inferred from the context, and dividing supported claims by total claims for a score from 0 to 1. A low score means the model added facts the retrieved documents do not support, which is a direct measure of hallucination in a RAG pipeline.
Fan-Out/Fan-In
An agent orchestration pattern where a coordinator splits work into parallel sub-tasks (fan-out), distributes them to multiple agents, waits for all results, and then combines them into a single output (fan-in). This pattern maximizes throughput for tasks with independent sub-problems. Claude Code uses fan-out/fan-in when spawning sub-agents for parallel research, coding, and testing tasks.
Feed-Forward Network (FFN)
The feed-forward network is the per-token block in every transformer layer that follows attention: two linear projections with a nonlinearity between them, applied to each position independently. In the original Transformer it expanded a 512-dimension vector to 2,048 and back with a ReLU in between. FFN layers hold most of a model's parameters, which is why Mixture of Experts models replace the single FFN with many expert FFNs and route each token to a few of them.
Few-Shot Learning
A prompting technique where you include a small number of input-output examples in the prompt to show the model the pattern you want it to follow. Instead of describing the format in words, you demonstrate it with 2-5 examples. Few-shot learning reliably improves output quality for classification, formatting, and domain-specific tasks without any model training.
Fine-tuning
The process of training a pre-existing model on a custom dataset to specialize its behavior. Fine-tuning adjusts model weights for specific tasks - like classifying support tickets or generating code in a particular framework - without training from scratch.
FlashAttention
An exact attention algorithm that produces the same result as standard attention but reorganizes the work around GPU memory. It uses tiling to compute attention in blocks that fit in fast on-chip SRAM, avoiding repeated reads and writes of the full attention matrix to slower high-bandwidth memory. The original paper by Tri Dao and colleagues reported a 3x training speedup on GPT-2 at 1K sequence length and made longer contexts practical.
Flow Matching
A way to train generative models by learning a vector field that carries samples from simple noise to real data along a chosen probability path. To generate, you integrate that field with an ODE solver. Lipman et al. introduced it in 2022: training needs no simulation, diffusion becomes one special case of path, and straight optimal-transport paths trained and sampled faster than diffusion paths. Many recent image, video and audio generators are trained with flow matching or the closely related rectified flow.
Foundation Model
A model trained on broad data at scale that can be adapted to many downstream tasks through prompting or fine-tuning. Stanford researchers coined the term in a 2021 report, citing BERT, DALL-E and GPT-3, to stress that these models are central to applications yet incomplete on their own. Because many products are built on the same few base models, any defects in a foundation model carry over to everything adapted from it.
Frequency and Presence Penalty
Two sampling parameters that discourage a model from repeating itself by lowering the scores of tokens it has already produced. Frequency penalty grows with how many times a token has appeared, which reduces verbatim repetition. Presence penalty applies once a token has appeared at all, which nudges the model toward new topics. In OpenAI's Chat Completions API both range from -2.0 to 2.0, and negative values encourage repetition instead.
Frontier Model
The most capable general-purpose models available at a given time, typically the latest flagship releases from the leading labs. In AI policy the term is narrower: Anderljung et al. (2023) define frontier AI models as highly capable foundation models that could possess dangerous capabilities sufficient to pose severe risks to public safety. The label is relative, since a model only counts as frontier until newer releases pass it.
FrontierMath
A benchmark from Epoch AI made up of hundreds of original, unpublished math problems written and vetted by expert mathematicians. The problems span fields from number theory and real analysis to algebraic geometry and category theory. A typical problem takes a specialist hours to solve, and the hardest take days. Answers are checked automatically, and because the problems are new, contamination risk is low. Top models solved under 2% when it launched in 2024.
FSDP (Fully Sharded Data Parallel)
A PyTorch training method that splits model parameters, gradients, and optimizer state across GPUs instead of copying them all onto every device as plain data parallelism does. Each GPU gathers the full parameters for one layer group only when it needs them for the forward or backward pass, then frees them, so the memory per device drops roughly with the number of GPUs. Meta's FSDP paper reports throughput comparable to DistributedDataParallel while training much larger models with near-linear scaling. It is a common choice for full fine-tuning of models too large for one GPU.
Function Calling
A model capability where the LLM outputs structured JSON describing which function to call and with what arguments, rather than plain text. This lets AI applications reliably trigger actions like database queries, API calls, or tool use based on natural language input.
G
GGUF
A binary file format for storing quantized language models, designed for efficient local inference with llama.cpp and tools built on it. GGUF files contain model weights, tokenizer data, and metadata in a single file. Both Ollama and LM Studio use GGUF as their primary model format. When you download a model from Hugging Face for local use, you are typically downloading a GGUF file.
Generative AI
AI systems that create new content - text, images, code, audio, video - rather than just classifying or analyzing existing data. LLMs like Claude and GPT are generative models trained to predict and produce sequences of tokens based on input prompts.
GEO (Generative Engine Optimization)
The practice of structuring web content so AI models cite and surface it in their responses. While SEO targets search engine rankings, GEO targets AI-generated answers by using clear definitions, structured data (JSON-LD), and authoritative formatting that models can extract.
Grounding
Connecting a model's responses to verified, external data sources rather than relying solely on its training data. Grounding techniques include RAG, tool use, and web search - they reduce hallucinations by giving the model facts to reference instead of generating from memory alone.
Guardrails
Safety constraints and validation layers applied to AI model inputs and outputs. Guardrails can block harmful content, enforce output formats, prevent prompt injection, filter sensitive data, and keep responses on-topic. They are typically implemented as middleware that wraps model calls rather than modifications to the model itself.
GDPval
An OpenAI benchmark that measures model performance on economically valuable work, with tasks covering 44 occupations across the 9 sectors that contribute most to U.S. GDP. Each task is built from the real work product of industry professionals averaging 14 years of experience, and expert graders compare model deliverables against human ones. OpenAI open-sourced a gold subset of 220 tasks with an automated grading service. Model release notes often quote GDPval-AA, an Elo-scored variant run by Artificial Analysis.
Golden Dataset
A fixed, curated set of realistic inputs paired with expert-approved reference answers, used as the ground truth for evaluating an LLM application. It works like a unit test suite: every prompt, model, or retrieval change is run against the same questions and the outputs are compared to the reference answers. Microsoft's guidance for Copilot quality assurance recommends about 150 question and answer pairs and never fewer than 100, and treats sustained drift from the reference answers as a signal to investigate.
GPQA Diamond
The hardest, highest-quality subset of GPQA: 198 graduate-level multiple-choice questions in biology, physics, and chemistry written by domain experts. A question makes the Diamond set only if both expert validators answer it correctly and most skilled non-experts get it wrong. In the original study, non-experts reached just 34% on the full set even with over 30 minutes and unrestricted internet access. It is a standard headline score for scientific reasoning in frontier model launches.
Gradient Descent
An optimization algorithm that trains a model by repeatedly nudging its weights in the direction that most reduces the loss, as given by the negative gradient. The size of each step is set by the learning rate. In practice models use stochastic or mini-batch gradient descent, which estimates the gradient from a small batch of examples instead of the full dataset, and optimizers like Adam and AdamW add momentum and per-parameter step sizes on top.
Greedy Decoding
A decoding strategy that always picks the single most likely next token at each step, with no randomness. It is the default in Hugging Face Transformers and is roughly what you get when you set temperature to 0. Greedy decoding works well for short, factual outputs and makes runs easier to reproduce, but it tends to repeat itself on long generations. It can also miss a better overall sequence that starts with a less likely token.
Grouped-Query Attention (GQA)
Grouped-query attention is a middle ground between multi-head and multi-query attention: query heads are split into groups, and each group shares one key head and one value head. With 8 KV heads serving 32 query heads, the KV cache shrinks by 4x with little quality loss. The GQA paper showed quality close to full multi-head attention at speeds close to MQA, and it is now standard in open models such as Llama, Mistral, and Qwen.
GRPO (Group Relative Policy Optimization)
A reinforcement learning algorithm introduced in the 2024 DeepSeekMath paper as a lighter variant of PPO that drops the separate value model. For each prompt it samples a group of responses and scores them. Each response is then judged by how its reward compares with the group's average, which saves memory and simplifies the training stack. GRPO powered DeepSeek-R1's reasoning training and is a common choice for RL fine-tuning open models with verifiable rewards.
GSM8K
A dataset of 8,500 grade school math word problems from OpenAI that take several steps of basic arithmetic to solve. It was built to expose how weak language models were at multi-step reasoning even on simple problems, and the original paper used it to show that training a verifier to rank candidate answers works. Frontier models have saturated it, but it is still widely used as a training set and a quick sanity check, including in GRPO fine-tuning tutorials.
H
Human-in-the-Loop
A design pattern where AI systems include explicit checkpoints for human review, approval, or correction before proceeding. Instead of running fully autonomously, the agent pauses at critical decision points and presents its plan or output for human validation. This pattern is essential for high-stakes tasks like production deployments, financial transactions, and content publishing where AI errors have real consequences.
Hybrid Search
A retrieval strategy that combines keyword-based search (BM25, TF-IDF) with semantic vector search (embeddings) to get the best of both approaches. Keyword search excels at exact matches and rare terms. Semantic search excels at finding conceptually related content. Hybrid search runs both in parallel and merges the results using reciprocal rank fusion or similar techniques. It consistently outperforms either approach alone in RAG systems.
Hallucination
When a model generates confident-sounding information that is factually incorrect or fabricated. Hallucinations happen because LLMs predict plausible-sounding text, not verified facts. Techniques like RAG, grounding, and structured output help reduce but do not eliminate hallucinations.
Hooks (Claude Code)
User-defined shell commands that run automatically at specific points in the Claude Code lifecycle - before a tool executes, after a tool completes, or when a notification fires. Hooks let you enforce project rules, run linters, or trigger custom workflows without modifying the agent itself.
HumanEval
A code generation benchmark from OpenAI made of 164 hand-written Python programming problems, each with a function signature, a docstring, and unit tests. A model passes a problem only if the code it writes passes the hidden tests, and results are reported as pass@k: the chance that at least one of k samples is correct. It was released in 2021 alongside the original Codex paper and became the standard coding score for years. Frontier models now score near the ceiling, so most evaluators have moved on to harder agentic benchmarks like SWE-bench.
Humanity's Last Exam (HLE)
A multimodal benchmark of 2,500 expert-written questions across dozens of subjects, including mathematics, the humanities, and the natural sciences. It was built because models had passed 90% on older tests like MMLU. Every question has one unambiguous, auto-gradable answer (multiple choice or short answer) that cannot be found with a quick lookup. Labs often report two scores, with and without tool use, so check which one a launch post is quoting.
Hybrid Reasoning Model
A single model that can either answer directly or think at length before answering, instead of shipping separate chat and reasoning models. Anthropic introduced Claude 3.7 Sonnet in February 2025 as the first generally available hybrid reasoning model, with a standard mode and an extended thinking mode plus an API budget for thinking tokens. Open models like Qwen 3 followed with a similar thinking and non-thinking switch. The point is to pay for deep reasoning only on the requests that need it.
Hyperparameters
Settings chosen by the developer that control how a model learns, as opposed to the weights the model learns itself. Common examples are learning rate, batch size, number of epochs, weight decay, warmup steps, and, for LoRA, the rank and alpha. Small changes can decide whether a run converges, so teams usually sweep them on small runs before committing compute to a full training job.
I
In-Context Learning
The ability of a language model to learn new tasks from examples or instructions provided in the prompt, without any weight updates or training. When you include examples in a prompt and the model follows the pattern, that is in-context learning. It is why few-shot prompting works and why well-structured context dramatically improves model performance. The quality of in-context learning scales with model size and context window length.
IDE (Integrated Development Environment)
A software application that combines a code editor, debugger, terminal, and tooling into one workspace. VS Code, Cursor, and Zed are popular IDEs. AI coding assistants increasingly integrate into IDEs or replace them entirely with CLI-based workflows.
IFEval
Instruction-Following Eval, a benchmark of about 500 prompts that each contain one or more verifiable instructions, such as "write more than 400 words" or "mention the keyword AI at least 3 times". It covers 25 instruction types, and every one can be checked with code. That means scoring needs no human graders or LLM judge and gives the same result every run. It is a standard score for how reliably a model follows formatting and constraint instructions.
Indirect Prompt Injection
Indirect prompt injection is a prompt injection that arrives through content the model reads, such as a web page, email, document, or tool result, instead of being typed by the user. Greshake et al. coined the term in 2023. They argued that LLM-integrated apps blur the line between data and instructions, and showed that injected text could steal data, change how an app behaves, and control which APIs it calls. It is the main risk for agents because the attacker never needs access to the chat, only to something the agent will read.
Input vs Output Token Pricing
The split pricing model where LLM APIs charge one rate per million tokens you send (input) and a higher rate per million tokens the model generates (output). Output is typically several times pricier: Claude Opus 5.5 lists $4 per million input tokens and $20 per million output tokens, a 5x ratio. Cached input reads bill far below the base input rate, so a task's real cost depends on cache hit rate and how much the model writes, not on the headline rates alone.
Instruction-Tuned Model
A base model that has been further fine-tuned on tasks phrased as natural-language instructions so it responds to requests instead of just continuing text. Google's FLAN paper showed that instruction tuning a 137B model on over 60 tasks substantially improved zero-shot performance on unseen task types. Most chat and "-Instruct" models add preference training such as RLHF on top, as OpenAI did with InstructGPT.
Interleaved Thinking
A Claude capability that lets the model think between tool calls within a single assistant turn, reasoning about each tool result before deciding what to do next. Without it, the model reasons once up front and then chains tool calls without reflecting on intermediate results. With adaptive thinking it is automatic on supported models, while older models on manual extended thinking needed the interleaved-thinking-2025-05-14 beta header. It matters most for agents that make many dependent tool calls.
J
Jailbreak
A jailbreak is a prompt written to get a model to produce output its safety training is meant to refuse. Wei, Haghtalab, and Steinhardt traced jailbreaks to two failure modes. The first is competing objectives, where being helpful conflicts with being safe. The second is mismatched generalization, where safety training doesn't cover inputs the model can still understand, such as encoded or obfuscated text. Unlike prompt injection, where an attacker hijacks an app through third-party content, a jailbreak is usually the user attacking the model's own safeguards.
JSON Mode
An API setting that guarantees a model's output is valid, parseable JSON, without guaranteeing that it matches any particular schema. In OpenAI's API you enable it with response_format type json_object in Chat Completions or text.format in the Responses API. You must also tell the model to produce JSON in the prompt, and the API errors if the word JSON does not appear in context. OpenAI describes it as a more basic version of Structured Outputs, which is the better choice when you need specific fields and types.
JSON Schema
A declarative vocabulary for describing the shape of JSON data: which properties exist, their types, which are required, and what values are allowed. The current version is 2020-12, split into a Core spec that defines the foundation and a Validation spec that defines keywords like type, enum, and required. In AI development it is how tool parameters, MCP tool inputs, and structured output formats are defined, and libraries like Zod can generate it from TypeScript types. Most providers support only a subset of the full spec for constrained output, so check their documented limitations.
K
Knowledge Cutoff
The date after which a model has no training data. Information published after the knowledge cutoff is invisible to the model unless provided through context (RAG, tool use, or web search). Knowing a model's cutoff date helps you decide when to supplement it with retrieved information. For example, asking a model about events after its cutoff without grounding will likely produce hallucinated or outdated answers.
Knowledge Base
A structured repository of information that an AI system can query to answer questions or provide context. In AI applications, knowledge bases are often backed by vector databases and used in RAG pipelines, letting models access up-to-date, domain-specific facts that were not part of their training data.
KV Cache
A store of the key and value tensors a transformer has already computed for earlier tokens, kept in memory so they can be reused at each new decoding step. Without it, an autoregressive model would recompute attention inputs for the whole sequence every time it predicts one more token. The trade-off is memory: the cache grows with context length and batch size, which is why long-context serving is often limited by KV cache size rather than model weights. Inference servers manage it with techniques like paged allocation, offloading, and quantized caches.
L
Latent Space
The compressed, high-dimensional representation that a neural network learns internally. Each point in latent space encodes a meaningful combination of features from the training data. Navigating latent space is how generative models interpolate between concepts, and it is why models can produce novel outputs that blend characteristics of things they have seen before.
Learning Rate
The hyperparameter that sets how large a step the optimizer takes when it updates weights from each gradient. Too high and training diverges or the loss spikes; too low and training crawls or stalls. Most LLM training changes it over time with a schedule, commonly a short warmup followed by cosine or linear decay, which PyTorch exposes through its learning rate schedulers. It is usually the first setting to tune when a fine-tune misbehaves.
Least Privilege (Agents)
Least privilege is the security rule that every program and user should run with the smallest set of privileges needed for the job, here applied to the tools, credentials, and permissions an agent holds. Saltzer and Schroeder stated the principle in 1975. For agents it means read-only tokens when a task only reads, API keys scoped to one task, narrow file and network allowlists, and no standing access to production. It limits the damage when an agent is confused, injected, or simply wrong.
Lethal Trifecta
The lethal trifecta is Simon Willison's name for a dangerous mix of three agent capabilities: access to private data, exposure to untrusted content, and the ability to communicate externally. When an agent has all three, an attacker can plant instructions in content the agent reads and get it to send the private data out. Willison argues that guardrails which catch most attacks are not enough. The reliable fix is to remove at least one of the three, for example by cutting outbound network access for any agent that reads untrusted input.
LiveBench
A general LLM benchmark built to resist test set contamination by adding new questions every month from recent sources such as math competitions, arXiv papers, news articles, and datasets. Answers are scored automatically against objective ground truth, not by an LLM judge or crowd votes. Tasks cover math, coding, reasoning, language, instruction following, and data analysis, and harder versions are released as models improve so the benchmark keeps separating them.
LiveCodeBench
A coding benchmark that keeps collecting new problems from LeetCode, AtCoder, and Codeforces contests over time, so models can be scored only on problems published after their training cutoff. That release-date filtering is how it limits data contamination, a known weakness of fixed sets like HumanEval. Beyond code generation, it also tests self-repair, code execution, and test output prediction.
LLM (Large Language Model)
A neural network trained on massive text datasets that can generate, summarize, translate, and reason about language. Models like Claude, GPT, Gemini, and Llama are LLMs. They power chatbots, coding agents, search tools, and most modern AI applications.
LLM Nondeterminism
The tendency of a language model endpoint to return different outputs for the same prompt, even at temperature 0. Thinking Machines Lab traced most of it to inference kernels that are not batch invariant: floating-point addition is not associative, so a request's numbers shift slightly depending on how many other requests share its batch, and batch size changes with server load. In practice, treat model output as a distribution, run evals more than once, and do not assume temperature 0 means repeatable.
LLM Tracing
Recording each step of an LLM application as a tree of timed spans, so you can see which prompts, model responses, tool calls, and handoffs happened in one request and how long each took. A trace covers one end-to-end workflow. Each span has start and end timestamps plus a parent span, which is how nested agent steps are pieced back together. The OpenAI Agents SDK, for example, traces every agent run, LLM generation, function tool call, guardrail, and handoff by default.
LMArena
A public leaderboard that ranks models by crowdsourced human preference: a user submits a prompt, two anonymous models answer, and the user votes for the better response before the model names are revealed. It started in 2023 as Chatbot Arena, built by LMSYS and UC Berkeley researchers, later became LMArena, and now runs as Arena at arena.ai. Votes are combined into ratings with a Bradley-Terry model, so scores reflect preference on real user prompts rather than correctness on a fixed test set. Separate arenas such as WebDev Arena rank models on specific task types.
Logits
The raw, unnormalized scores a language model's output layer assigns to every token in its vocabulary at each step, before softmax turns them into probabilities. Higher logits mean the model considers that token more likely to come next. Sampling controls like temperature, top-p, repetition penalties, and logit bias all work by modifying logits before a token is picked. Some classifiers built on LLMs read the logits of just a few tokens, such as yes and no, to get a confidence score.
Logprobs
The log probabilities of the tokens a model generated, returned by the API alongside the text. A logprob is log(p), where p is the probability of that token given everything before it, so values closer to zero mean higher confidence. In OpenAI's Chat Completions API you enable them with logprobs: true and can request up to 20 alternative tokens per position with top_logprobs. Developers use them for classification confidence thresholds, autocomplete decisions, and calculating perplexity.
Long Context
The ability of a model to accept and reason over very large inputs in a single request, now commonly hundreds of thousands to 1 million or more tokens. It lets you pass whole codebases, long documents, or hours of transcripts directly instead of chunking them through retrieval. Google's Gemini docs note that accuracy drops when a task needs many facts rather than one, that putting the query at the end of a long prompt helps, and that context caching is the main lever for keeping repeated long prompts affordable.
Long-Horizon Tasks
Tasks that take an agent many steps and a long time to finish, measured in hours of equivalent human work rather than one prompt and reply. METR measures this with the 50% time horizon: the length of task, timed by skilled humans, that a model completes successfully half the time. METR's paper found that frontier time horizons have doubled roughly every seven months since 2019. It attributes the gains mainly to better reliability and to models recovering from their own mistakes.
LoRA (Low-Rank Adaptation)
A parameter-efficient fine-tuning method that trains a small set of adapter weights instead of modifying the full model. LoRA makes fine-tuning practical on consumer hardware and is widely used in the open-source model community for creating specialized model variants.
Lost in the Middle
The finding that language models use information at the beginning or end of a long prompt much better than information buried in the middle. Liu et al. (2023) showed this U-shaped accuracy curve on multi-document question answering and key-value retrieval, even for models built for long context. It is why prompt guides recommend putting critical instructions and the question at the start or end of a long input rather than mid-document.
M
MCP Client
An application that connects to MCP servers to use the tools, resources, and prompts they expose. Claude Code, Cursor, Windsurf, and the Claude desktop app are all MCP clients. A client discovers what capabilities a server offers, presents them to the AI model, and routes the model's tool calls to the appropriate server. A single client can connect to multiple MCP servers simultaneously.
MCP (Model Context Protocol)
An open protocol created by Anthropic that standardizes how AI applications connect to external data sources and tools. MCP servers expose resources, tools, and prompts through a common interface so any MCP-compatible client can use them without custom integration code.
MCP Apps
An extension promoted to first-class status in the 2026-07-28 Model Context Protocol spec that lets a server return a sandboxed, server-rendered UI instead of only text. A tool can hand the client a real interface - a form, a table, a control panel - changing the design space from returning a string to returning an interaction. Because server-rendered UI is untrusted content, clients must render it in a sandbox.
MCP Tasks
A Model Context Protocol extension, made first-class in the 2026-07-28 spec, that gives long-running work a proper home - builds, deployments, long agent runs, and batch jobs that do not finish inside a single request. Because the protocol's core is now stateless, Tasks is built around resumable, pollable state rather than a held-open connection, so any server instance can advance or report on a task through a shared task store. Clients support it by handling long operations through the extension's polling model.
MCP Resource
A read-only data source exposed by an MCP server. Resources provide context to the AI model - things like configuration files, database records, documentation, or API state. Unlike tools (which perform actions), resources are passive data that the model reads for information. Resources are identified by URIs and can return text, JSON, or binary content.
MCP Server
A program that exposes tools, resources, and prompt templates to AI clients through the Model Context Protocol. MCP servers can provide access to databases, APIs, file systems, deployment pipelines, or any external service. They communicate with clients over stdio (spawned as a child process) or HTTP/SSE (running as a web service). Anyone can build and publish an MCP server.
MCP Tool
A function exposed by an MCP server that an AI agent can call to perform an action. Tools have a name, description, input schema (defined with Zod or JSON Schema), and a handler function. When an AI model decides to use a tool, the MCP client validates the inputs, calls the server, and returns the result to the model. Tools are the most commonly used MCP capability.
MCP Transport
The communication layer between an MCP client and server. The two standard transports are stdio (the client spawns the server as a child process and communicates via stdin/stdout) and HTTP with Server-Sent Events (the server runs as a web service). Stdio is simpler and used for local development. HTTP/SSE is used for remote servers, shared team infrastructure, and production deployments.
Mixture of Experts (MoE)
A model architecture that routes each input to a small subset of specialized sub-networks ("experts") rather than activating the entire model. A gating network decides which experts handle each token, so the model can have a massive total parameter count while only using a fraction of them per inference pass. MoE powers models like Mixtral and GPT-4, delivering strong performance at lower compute cost than dense models of equivalent size.
Multi-Agent Systems
Architectures where multiple AI agents collaborate on a task, each handling a specialized role. One agent might research while another writes code and a third reviews it. Multi-agent patterns include orchestrator-worker, pipeline, and swarm topologies.
Model Collapse
A phenomenon where AI models trained on AI-generated data progressively lose quality and diversity over generations. If Model A generates training data for Model B, and Model B generates training data for Model C, each generation drifts further from the original data distribution. Rare patterns and minority viewpoints disappear first. Model collapse is a growing concern as AI-generated content becomes a larger share of internet data, and it is one reason human-curated training data remains valuable.
Multimodal RAG
An extension of RAG that retrieves and processes not just text but also images, tables, code snippets, diagrams, and other non-text content. A multimodal RAG system might embed images alongside text, retrieve relevant diagrams when answering questions about architecture, or extract data from tables in PDF documents. As models become more capable of understanding multiple modalities, multimodal RAG closes the gap between what a model can process and what a knowledge base contains.
Mythos 5
The uncapped sibling of Fable 5, announced by Anthropic on June 9, 2026 as the same underlying model with the safeguards lifted in some areas. Where Fable 5 wraps the weights in classifiers that route sensitive requests to Opus 4.8, Mythos 5 has those classifiers partially or fully removed depending on the access tier, and it stays behind a government-coordinated access program rather than shipping for general use. Both are Mythos-class, a tier above Opus, priced at $10 per million input and $50 per million output tokens.
Multi-Modal
AI models that can process and generate more than one type of data - text, images, audio, video, or code. A multi-modal model can analyze a screenshot, read the text in it, and generate code that reproduces the UI, all in a single interaction.
Mamba
Mamba is a sequence model architecture built on selective state space layers, where the SSM parameters depend on the current token so the model can choose what to remember or forget. It drops attention entirely, scales linearly with sequence length, and the paper reports about 5x higher inference throughput than transformers. Mamba layers are now most often used inside hybrid models such as NVIDIA's Nemotron family rather than on their own.
MATH Benchmark
A dataset of 12,500 competition mathematics problems, each with a full step-by-step solution, released by Dan Hendrycks and colleagues in 2021. Models are graded on the final answer. The commonly reported MATH-500 is a subset of 500 test problems that OpenAI chose at random for its Let's Verify Step by Step paper. Reasoning models now score above 90% on MATH-500, so harder sets like AIME and FrontierMath carry more signal.
Max Tokens
The request parameter that sets a hard ceiling on how many tokens a model may generate in one response. It caps output, not input, and the model can stop earlier on its own; if it reaches the cap, the output is cut off and the Claude API reports stop_reason "max_tokens". Setting it too low is a common cause of truncated JSON and incomplete tool calls, which have to be retried with a higher limit. Each model has its own maximum value for the parameter.
Max Turns
A cap on how many tool-use round trips an agent loop may run before it is forced to stop. In the Claude Agent SDK, a turn is one cycle: the model asks for tool calls, the SDK runs them, and the results go back to the model. When maxTurns is reached, the run ends with an error_max_turns result. Claude Code offers the same limit as --max-turns in print mode, unlimited by default, and it pairs well with a spend cap like --max-budget-usd.
MCP Authorization (OAuth 2.1)
MCP authorization is the part of the Model Context Protocol spec that defines how a client gets permission to call a protected MCP server over an HTTP-based transport. The server acts as an OAuth 2.1 resource server and the client as an OAuth 2.1 client. Clients must use PKCE, find the authorization server through protected resource metadata (RFC 9728), and use resource indicators (RFC 8707) to tie each token to one specific server. Servers on the local stdio transport skip this flow and read credentials from the environment instead.
MCP Tool Poisoning
MCP tool poisoning is an attack where a malicious MCP server hides instructions in a tool's description, which the model reads but the user usually never sees. Invariant Labs disclosed it in April 2025 using an innocent-looking add tool whose hidden description told the agent to read ~/.cursor/mcp.json and ~/.ssh/id_rsa and pass their contents back through a tool argument. Related variants include rug pulls, where a server changes a tool description after the user approved it, and tool shadowing, where one server's description changes how the agent uses another server's trusted tools. Suggested mitigations include showing users the full tool descriptions and pinning server versions.
Mechanistic Interpretability
Mechanistic interpretability is the research field that tries to reverse engineer what a neural network computes internally into algorithms humans can understand, the way a programmer might decompile a binary back into readable source code. It looks inside the model rather than judging only its outputs. Researchers identify features, which are directions in activation space that represent concepts, and circuits, which are the pathways connecting them. Anthropic's 2021 paper A Mathematical Framework for Transformer Circuits is a foundational work in the field.
Message Roles
The labels that mark who said what in a chat API request: typically system or developer for application instructions, user for end-user input, assistant for model output, and tool for tool results. OpenAI documents developer messages as taking priority over user messages. Anthropic's Messages API takes instructions in a top-level system field and alternates user and assistant turns, and because these APIs are stateless, every request resends the full role-tagged history.
METR Time Horizon
A capability metric from METR that describes what an AI system can do in human terms: the length of task, measured by how long skilled humans take to do it, that a model completes with 50% success. METR timed experts on software and research tasks, then fit each model's success rate against task length. The original 2025 paper put Claude 3.7 Sonnet at about 50 minutes and found the frontier horizon doubling roughly every seven months since 2019. METR keeps measuring new models, and the number is widely used as a proxy for autonomous agent capability.
MicroVM Sandbox
A microVM sandbox runs each workload in its own lightweight virtual machine with a separate guest kernel, giving VM-level isolation at close to container speed. The reference design is Firecracker, AWS's open source KVM-based virtual machine monitor. Its 2020 NSDI paper reports under 5MB of memory overhead, under 125ms to boot to application code, and up to 150 microVMs created per second per host. Agent sandbox services such as E2B and Vercel Sandbox run on Firecracker microVMs, which is a stronger boundary than containers that share the host kernel.
Min-P Sampling
A sampling method that keeps only tokens whose probability is at least a set fraction of the most likely token's probability, then samples from what remains. Because the cutoff scales with the top token, the filter is strict when the model is confident and loose when many tokens are plausible. Its authors showed it holds quality better than top-p at higher temperatures. It is supported in Hugging Face Transformers, vLLM, llama.cpp, and other open-source inference stacks.
Mixed Precision Training
A technique for training neural networks that runs most of the math in lower-precision formats like FP16 or BF16 while keeping critical values in 32-bit. The 2017 paper from NVIDIA and Baidu that introduced it kept a full-precision master copy of the weights and scaled the loss so small half-precision gradients would not round to zero, cutting memory use nearly in half. BF16 mixed precision is now the default for training LLMs, and some labs push parts of training down to FP8.
Mixture of Agents
An ensemble technique where several LLMs answer the same prompt in layers. Each agent in a layer gets every output from the previous layer as extra context before writing its own response. Wang et al. introduced the approach in 2024 (arXiv 2406.04692), and their version built only from open-source models scored 65.1% on AlpacaEval 2.0, against 57.5% for GPT-4o. Each request costs many model calls, so it suits outputs where quality matters most, not high-volume traffic.
MLE-bench
An OpenAI benchmark that tests AI agents on machine learning engineering, using 75 real Kaggle competitions that require preparing data, training models, and running experiments. Each submission is graded against that competition's human leaderboard, so results read as Kaggle medals. In the original paper the best setup, o1-preview with the AIDE scaffold, reached at least bronze-medal level in 16.9% of competitions. It is often cited in discussions of AI automating AI research.
MMLU
Massive Multitask Language Understanding, a multiple-choice benchmark covering 57 subjects such as elementary math, US history, computer science, and law. Each question has four answer options, and it measures broad world knowledge and problem solving rather than any single skill. It was the default headline knowledge score for LLMs from 2020 onward, but frontier models now score above 90%, so it no longer separates them well.
MMLU-Pro
A harder version of MMLU that adds more reasoning-focused questions, removes trivial and noisy ones, and expands each question from four answer choices to ten. The extra options make guessing less effective and drop model accuracy by 16 to 33 points compared with MMLU. Scores also shift less when the prompt wording changes, and chain-of-thought reasoning helps on it where it did not on the original.
MMMU
A multimodal benchmark of about 11.5K college-level questions drawn from exams, quizzes, and textbooks, where answering requires reading an image as well as the text. It covers six disciplines, 30 subjects, and 183 subfields, with images ranging from charts and diagrams to music sheets and chemical structures. At launch in 2023, GPT-4V scored 56% and Gemini Ultra 59%. Vision-capable model releases still quote MMMU or its harder MMMU-Pro variant.
Model Card
A model card is a short document published with a trained machine learning model that explains its intended uses, its limitations, and how it performs across different conditions and groups. Margaret Mitchell, Timnit Gebru, and co-authors proposed the format in the 2018 paper Model Cards for Model Reporting. On Hugging Face, a model's README serves as its model card and usually covers training data, license, evaluation results, and known risks. Read it before you adopt an open-weight model.
Model Cascade
A cost-saving setup where a request goes to a cheap model first and moves up to stronger, more expensive models only when the answer fails a quality or confidence check. The FrugalGPT paper (Chen, Zaharia and Zou, 2023) formalized the LLM cascade and reported matching GPT-4 performance at up to 98% lower cost in its experiments. A router picks one model up front, while a cascade tries models in order and pays extra only on the hard cases.
Model Merging
Combining the weights of two or more models into a single model without further training, usually by averaging or interpolating their parameters. The 2022 model soups paper showed that averaging several fine-tunes of the same base model often beats the best individual fine-tune, with no extra inference cost, unlike an ensemble. It works best when the models share an architecture and a common starting checkpoint, and it is widely used in the open-weights community to blend skills from separate fine-tunes.
MTEB
The Massive Text Embedding Benchmark, a suite for comparing embedding models across many tasks instead of a single similarity dataset. The original release covered 8 task types, including retrieval, reranking, clustering, classification, and semantic textual similarity, across 58 datasets and 112 languages. Its public leaderboard is the usual first stop when choosing an embedding model for RAG. The paper found no single model wins every task, so compare scores on the task type you actually need.
Multi-Head Attention
Multi-head attention runs several attention operations in parallel, each with its own learned query, key, and value projections, then concatenates their outputs and projects them back to the model dimension. Each head can specialize in a different relationship between tokens, such as syntax or long-range references. It was introduced in the 2017 "Attention Is All You Need" paper, and its per-head keys and values are what fill the KV cache during inference, which is why later variants like MQA, GQA, and MLA all target that cost.
Multi-Head Latent Attention (MLA)
Multi-head latent attention is an attention design introduced by DeepSeek that compresses keys and values into a small shared latent vector, so the model caches that latent instead of full per-head keys and values. In the DeepSeek-V2 paper it cut the KV cache by 93.3% versus DeepSeek 67B and raised maximum generation throughput 5.76x. MLA has since been reused in other open models, including Kimi Linear, which mixes it with linear attention layers.
Multi-LoRA Serving
Serving many LoRA fine-tunes from one shared base model by loading each request's small adapter on demand, instead of deploying a separate full model for every task or customer. Systems like S-LoRA keep adapters in host memory and page the active ones onto the GPU. They also batch requests that use different adapters together with custom kernels. The S-LoRA paper reports serving thousands of adapters on a single GPU, which makes per-tenant fine-tuning practical to host.
Multi-Query Attention (MQA)
Multi-query attention is a variant of multi-head attention where all query heads share a single key head and a single value head. Proposed by Noam Shazeer in 2019, it cuts the size of the KV cache and the memory bandwidth needed to load it at every decoding step, which makes token generation much faster. The trade-off is some quality loss, which is why most current models use grouped-query attention as a compromise.
Multi-Token Prediction (MTP)
A training objective where a language model learns to predict the next several tokens at each position instead of only the next one, using extra output heads on a shared model trunk. Meta's 2024 paper found it improved sample efficiency and coding benchmarks, with a 13B model solving 12% more HumanEval problems than a next-token baseline. The extra heads can also be reused at inference as a built-in draft for speculative decoding, which made 4-token models up to 3x faster.
Muon Optimizer
An optimizer for the 2D weight matrices in a neural network's hidden layers that takes the SGD-momentum update and orthogonalizes it with a Newton-Schulz iteration before applying it. The name stands for MomentUm Orthogonalized by Newton-Schulz, and Keller Jordan's write-up credits it with NanoGPT and CIFAR-10 training speed records. Embeddings, output heads, and scalar parameters are still handled by a standard optimizer like AdamW. PyTorch now ships it as torch.optim.Muon, and labs such as Cursor and Thinking Machines use it for large training runs.
N
Needle in a Haystack
A long-context test that hides a specific fact (the needle) inside a long filler document (the haystack) and asks the model to retrieve it. Greg Kamradt's open source harness popularized it, sweeping context length and needle depth from 0 to 100 percent and scoring each combination. Many models now score near perfectly on the single-needle version, so benchmarks like RULER add multiple needles, multi-hop tracing, and aggregation to expose weaknesses it misses.
Neural Network
A computing architecture loosely inspired by biological neurons, made up of layers of interconnected nodes that transform input data through learned weights and activation functions. Neural networks are the foundation of modern AI. Stacking many layers creates "deep" neural networks, which is where the term deep learning comes from.
Next-Token Prediction
The training objective behind GPT-style language models: given a sequence of tokens, predict a probability distribution over the token that comes next. Pre-training minimizes the cross-entropy loss of that prediction across a huge text corpus. The same mechanism produces output at inference time, one token at a time. OpenAI's GPT-4 technical report describes the model as a Transformer pre-trained to predict the next token in a document, with post-training then shaping its behavior.
NLP (Natural Language Processing)
The field of AI focused on enabling computers to understand, interpret, and generate human language. NLP covers everything from tokenization and sentiment analysis to machine translation and conversational AI. LLMs represent the current state of the art in NLP, but the field also includes older techniques like TF-IDF, named entity recognition, and dependency parsing.
O
Orchestrator-Worker Pattern
A multi-agent architecture where a central orchestrator agent receives a task, decomposes it into sub-tasks, assigns each to a specialized worker agent, monitors progress, and synthesizes results. The orchestrator handles planning and coordination while workers handle execution. This is the most structured multi-agent pattern and is used by Claude Code (parent agent + sub-agents), CrewAI (hierarchical process), and LangGraph (orchestrator node).
Open Source Models
AI models released with publicly available weights that anyone can download, run, fine-tune, and deploy. Models like Llama, Qwen, Mistral, and DeepSeek offer alternatives to closed APIs, enabling local inference, customization, and full control over your AI stack.
Orchestration
The coordination layer that manages how AI agents, tools, and data sources work together in a pipeline. Orchestration handles routing prompts to the right model, managing context across steps, retrying failures, and combining results from parallel sub-tasks.
Online Evaluation
Scoring an LLM application's behavior on live production traffic as it happens, rather than on a curated test set before deployment. Because production traces have no reference outputs, online evaluators focus on reference-free checks such as safety, format, tone, and LLM-as-a-judge quality scores. Offline evaluation is the counterpart: it runs on datasets with expected answers and is used for pre-deployment and regression testing.
OpenAI-Compatible API
An API that accepts the same request and response shapes as OpenAI's Chat Completions endpoint, so existing OpenAI SDKs and tools work after changing only the base URL, API key, and model name. Many providers, gateways, and local runtimes expose one to make switching models cheap. Compatibility is usually partial: Anthropic's layer, for example, silently ignores fields like response_format and seed, does not support prompt caching, and recommends the native API for production use.
OpenTelemetry GenAI Semantic Conventions
A vendor-neutral OpenTelemetry specification that sets standard span names, attributes, metrics, and events for generative AI work. It covers model inference, agent runs, tool execution, and Model Context Protocol calls. Shared attributes like gen_ai.operation.name, gen_ai.request.model, and gen_ai.usage.input_tokens let any compliant tracing backend read telemetry from any instrumented framework. The conventions are still in Development status and now live in their own repository, open-telemetry/semantic-conventions-genai.
OSWorld
A benchmark that runs multimodal agents inside real virtual machines and asks them to complete open-ended computer tasks across desktop apps, file operations, and multi-app workflows. The original set has 369 tasks, each with a scripted starting state and an execution-based checker that inspects the actual result rather than the agent's description of it. At launch humans completed about 72% of tasks and the best model about 12%. It is now the headline number for computer-use models.
OWASP Top 10 for LLM Applications
The OWASP Top 10 for LLM Applications is a ranked list of the most critical security risks in apps built on large language models, published by the OWASP Gen AI Security Project. The 2025 edition runs from prompt injection (LLM01) through sensitive information disclosure, supply chain, data and model poisoning, improper output handling, excessive agency, system prompt leakage, vector and embedding weaknesses, and misinformation, to unbounded consumption (LLM10). Each entry gives the risk, example attacks, and mitigations. Teams often use it as a checklist when threat-modeling agents and RAG apps.
P
PagedAttention
An attention algorithm that stores the KV cache in fixed-size blocks that do not need to be contiguous in GPU memory, borrowing the virtual memory and paging idea from operating systems. Allocating cache on demand nearly eliminates the fragmentation and over-reservation that limited batch sizes in earlier servers, and lets requests share blocks for common prefixes or parallel samples. It is the core of vLLM, whose paper reported 2-4x higher throughput than FasterTransformer and Orca at the same latency.
Parallel Tool Calls
The ability of a model to request several tool calls in a single response instead of one call per turn. Your application runs them, sequentially or concurrently, and returns one result for each call, all together in the next message. This cuts round trips when calls are independent, such as reading three files at once. Both major APIs enable it by default; you turn it off with parallel_tool_calls: false in OpenAI's API or disable_parallel_tool_use: true inside tool_choice in Anthropic's.
Parameter Count
The number of learned weights in a model, usually given in billions (7B, 70B, 405B). It is the standard measure of model size and sets memory needs: at 16-bit precision each parameter takes 2 bytes, so a 70B model needs about 140 GB for its weights alone. Kaplan et al.'s scaling laws showed that loss falls as a power law as parameter count grows, which is why it became the headline spec. Mixture of Experts models have separate total and active counts, so check which one is being quoted.
Pass-Hat-k (pass^k)
A reliability metric that counts a task as solved only if all k independent attempts succeed, the strict counterpart to pass@k. It was introduced in the tau-bench paper and is estimated from n trials with c successes as C(c, k) / C(n, k). Because a single failure sinks the score, pass^k drops as k grows for any agent that is only right some of the time: in tau-bench, strong agents solved under 50% of tasks and fell below 25% at pass^8 in retail. It is the better metric when an agent will repeat the same kind of task in production.
pass@k
An evaluation metric that counts a problem as solved if at least one of k sampled attempts passes, usually checked by unit tests. It was popularized by OpenAI's 2021 Codex paper, which introduced HumanEval and an unbiased estimator: generate n samples, count the c that pass, and compute 1 - C(n-c, k) / C(n, k). pass@1 approximates single-try accuracy, while a larger k shows what repeated sampling can reach if you have a reliable way to pick the right answer.
PEFT (Parameter-Efficient Fine-Tuning)
A family of fine-tuning methods that adapt a large pretrained model by training only a small number of new or selected parameters while the original weights stay frozen. Techniques include LoRA, QLoRA, and prompt or prefix tuning. They cut GPU memory and storage sharply because each task produces a small add-on file instead of a full model copy. Hugging Face's PEFT library is a widely used reference implementation, and it reports performance comparable to full fine-tuning.
Permissions (Claude Code)
The approval system that controls what actions Claude Code can take on your system. By default, Claude Code asks for permission before writing files, running commands, or accessing the network. You can configure permission levels from strict (approve everything) to permissive (auto-approve safe operations) to autonomous (approve all operations without prompting). Settings files and hooks provide fine-grained control over which specific actions require approval.
Perplexity
A metric that measures how well a language model predicts a sequence of tokens. Lower perplexity means the model is less "surprised" by the text and assigns higher probability to the correct next tokens. Perplexity is commonly used to compare language models during training and evaluation, though it does not always correlate perfectly with real-world task performance.
PII Redaction
PII redaction finds personally identifiable information, such as names, email addresses, phone numbers, and card or ID numbers, and removes or replaces it before the data reaches a model, a log, or a third party. Open-source tools like Presidio detect PII with named entity recognition, regular expressions, rule-based logic, and checksums, then mask it or swap in placeholders. Presidio's docs warn that automated detection cannot guarantee it finds every piece of sensitive data. Treat redaction as one layer that works alongside access controls and retention limits.
Pipeline Parallelism
A model-parallel technique that splits a network by layers into sequential stages on different accelerators, passing activations from one stage to the next. To keep stages from sitting idle, GPipe splits each batch into micro-batches so several stages work at once, and reported almost linear speedup as a model was partitioned across more devices. It communicates less often than tensor parallelism, so it is often used across servers, at the cost of pipeline bubbles where some stages wait.
Planning (Agent)
The phase in an agent's workflow where it analyzes a task, breaks it into steps, and determines the order of operations before taking any action. Good planning reduces wasted tool calls and dead ends. Planning can be explicit (the agent writes out a plan before executing) or implicit (the model reasons through steps internally). Claude Code's plan mode lets users review the agent's plan before it starts making changes.
Positional Encoding
Positional encoding is the signal a transformer uses to know where each token sits in a sequence, since self-attention on its own treats input as an unordered set. The original Transformer added fixed sine and cosine waves of different frequencies to each token embedding. Most modern LLMs instead use Rotary Position Embedding (RoPE), which rotates query and key vectors by position, or ALiBi, which biases attention scores by distance, and the choice largely decides how well a model handles contexts longer than it was trained on.
Post-Training
Everything done to a pretrained base model to turn it into a useful assistant. That usually means supervised fine-tuning, then preference tuning such as RLHF or DPO, then reinforcement learning on tasks with checkable answers. Post-training uses far less compute than pretraining, but it largely decides instruction following, tone, safety behavior, tool use, and reasoning style. AI2's Tulu 3 published a fully open recipe of SFT, then DPO, then RLVR on top of Llama 3.1 base models.
PPO (Proximal Policy Optimization)
A policy-gradient reinforcement learning algorithm, published by OpenAI researchers in 2017, that improves a policy in small, stable steps by clipping its objective so no single update moves too far. It became the standard optimizer for RLHF and was used to train InstructGPT. In that setting it runs alongside a learned value model (critic) and a KL penalty that keeps the model close to its starting point. That extra critic network is the memory cost that later methods like GRPO set out to remove.
Prefill
The first phase of LLM inference, where the model processes the entire input prompt in parallel and builds the KV cache before producing any output. Because all prompt tokens are handled at once, prefill saturates GPU compute even at small batch sizes. Its duration grows with prompt length, which makes it the main driver of time to first token on long contexts.
Prefix Caching
An inference-engine optimization that keeps the KV cache from earlier requests and reuses it when a new request starts with the same tokens, so the shared prefix skips prefill. In vLLM each full cache block is hashed from its tokens plus its parent block's hash, so a block only matches when everything before it matches too, and unused blocks are evicted least recently used first. Provider prompt caching applies the same idea as a billed API feature, and both reward putting static content like system prompts and tool definitions at the start of the prompt.
Pretraining
The first and most expensive stage of building a language model, where it learns to predict the next token across a huge unlabeled corpus of web text, books, and code. Pretraining is where the model picks up language, facts, and general reasoning ability. The result is a base model that continues text rather than following instructions. GPT-3 showed that scaling pretraining alone produces strong few-shot ability, and every modern LLM still starts this way before post-training shapes it into an assistant.
Process Reward Model (PRM)
A reward model that scores every intermediate step of a solution, not just the final answer. OpenAI's Let's Verify Step by Step compared this process supervision against outcome supervision on the MATH dataset and found process supervision trained a much more reliable model, solving 78% of a representative test subset. The paper also released PRM800K, a dataset of 800,000 step-level human labels, and PRMs are commonly used to rerank sampled reasoning traces.
Programmatic Tool Calling
A Claude API feature where the model writes Python code that calls your tools as functions inside a code execution container, instead of making one model round trip per tool call. When the code calls a tool, execution pauses, your app returns the result, and the code continues; only the final output enters Claude's context, not the intermediate results. You opt a tool in by adding code execution to its allowed_callers field. It reduces latency and token use in workflows that loop over many calls or filter large results.
Prompt Caching
A provider feature that caches the processing of static prompt prefixes so repeated requests with the same system prompt or context pay the computation cost only once. Subsequent requests that share the cached prefix skip re-processing, resulting in lower latency and reduced costs (typically 90% cheaper for cached tokens). Prompt caching is especially valuable for RAG systems, agent loops, and any application that sends the same large context repeatedly.
Prompt Chaining
A workflow that splits a task into a fixed sequence of LLM calls, where each call works on the output of the one before it. Between steps you can add programmatic checks, which Anthropic calls gates, to confirm an intermediate result is on track before moving on. Chaining gives up some latency in exchange for accuracy, because each call does a narrower, easier job. A typical chain writes an outline, checks it against criteria, then writes the document from the outline.
Prompt Engineering
The practice of designing and iterating on prompts to get consistent, high-quality outputs from AI models. Good prompt engineering involves clear instructions, examples (few-shot), structured output formats, and systematic testing - not guesswork.
Prompt Injection
An attack where malicious input tricks an AI model into ignoring its instructions and following attacker-supplied commands instead. Direct injection embeds instructions in user input. Indirect injection hides instructions in external data the model reads (web pages, documents, emails). Prompt injection is the most significant security risk in AI applications. Defenses include input sanitization, output filtering, privilege separation, and guardrail layers.
Prompt Regression Testing
Running a fixed suite of test inputs and assertions against every prompt or model change so that a tweak that fixes one case does not silently break others. Tools like promptfoo run these suites in CI and fail the build when tests error or the pass rate drops below a threshold, such as 95%. Assertions range from cheap string and schema checks to model-graded rubrics.
Prompt Template (MCP)
A reusable prompt structure exposed by an MCP server. Prompt templates define a prompt skeleton with parameters that users fill in, standardizing how AI interacts with a specific domain. For example, a code review prompt template might accept code and language as parameters and produce a structured review prompt. Templates help enforce consistency across teams and reduce the need for manual prompt crafting.
Provider (AI)
A company or service that hosts AI models and exposes them through an API. Major providers include Anthropic (Claude), OpenAI (GPT), Google (Gemini), and Meta (Llama via third parties). Frameworks like the Vercel AI SDK abstract over providers so you can switch models without rewriting code.
Q
QLoRA
A fine-tuning method that trains LoRA adapters on top of a frozen base model whose weights are quantized to 4 bits. This cuts memory enough to fine-tune a 65B-parameter model on a single 48GB GPU. Dettmers et al. introduced it in 2023 along with a 4-bit NormalFloat (NF4) data type, double quantization of the quantization constants, and paged optimizers that absorb memory spikes. The paper reports quality that matches full 16-bit fine-tuning.
Quantization
The process of reducing the numerical precision of a model's weights, typically from 16-bit or 32-bit floating point down to 8-bit, 4-bit, or even lower. Quantization dramatically reduces model size and memory usage, making it possible to run large models on consumer GPUs and edge devices. The trade-off is a small loss in output quality, though modern quantization techniques like GPTQ and AWQ minimize this gap.
R
ReAct Pattern
An agent architecture that interleaves Reasoning and Acting in a loop. The agent reasons about what to do next, takes an action (calls a tool), observes the result, and then reasons again about the next step. This reason-act-observe cycle repeats until the task is complete. ReAct combines the strengths of chain-of-thought reasoning with tool use, and it is the foundational pattern behind most modern AI agents including Claude Code.
RAG (Retrieval Augmented Generation)
A pattern that improves LLM responses by retrieving relevant documents from an external knowledge base and injecting them into the prompt before generation. RAG gives the model up-to-date, domain-specific context without fine-tuning, reducing hallucinations and keeping responses grounded in real data.
Refusal Fallback
A safety architecture where a model routes blocked queries to a more constrained model instead of refusing outright. Fable 5 pioneered this for general use: when its classifiers flag a cybersecurity, biology and chemistry, or distillation request, the query is silently handed off to Claude Opus 4.8 and the user is notified. For API users the fallback is not automatic and must be configured, so agent fleets need to handle the refusal or fallback signal explicitly before shipping.
Reflection (Agent)
A technique where an AI agent evaluates its own output before returning it to the user. After generating a response, the agent prompts itself to critique the result for accuracy, completeness, and quality, then revises based on its own feedback. Reflection adds an extra inference step but significantly improves output quality. Some agents run multiple reflection cycles, progressively refining their work.
Reasoning Models
Models specifically trained or prompted to show their step-by-step thinking process before producing a final answer. Models like o1, o3, and Claude with extended thinking use chain-of-thought reasoning to tackle complex math, logic, and coding problems more reliably.
Retrieval
The process of finding relevant documents, passages, or data from a knowledge base in response to a query. In AI applications, retrieval typically combines embedding-based semantic search with keyword search to find the most relevant context for a model. The quality of retrieval directly determines the quality of RAG systems. Better retrieval means fewer hallucinations and more accurate, grounded responses.
RLHF (Reinforcement Learning from Human Feedback)
A training technique that fine-tunes a model using human preference judgments. Humans rank model outputs from best to worst, and those rankings train a reward model. The language model is then optimized via reinforcement learning to produce outputs the reward model scores highly. RLHF is a key step in making raw pre-trained models helpful, harmless, and aligned with human intent.
Rate Limits (RPM and TPM)
Caps on how much traffic an organization can send to a model API, measured in requests per minute (RPM) and tokens per minute (TPM). Anthropic splits the token cap into input tokens per minute (ITPM) and output tokens per minute (OTPM), refills capacity continuously with a token bucket rather than resetting each minute, and does not count cached input reads toward ITPM on most models. Exceeding any limit returns HTTP 429, usually with a retry-after header, and limits rise with your usage tier.
Reasoning Effort
An API setting that tells a reasoning model how much work to put into a response, trading answer quality against latency and token cost. OpenAI exposes it as reasoning.effort with levels such as low, medium, and high, and some models add none, minimal, xhigh, or max. Anthropic's equivalent is the effort parameter, which shapes all output tokens including thinking, text, and tool calls. Defaults vary by model, so check the model page before relying on one.
Reasoning Summaries
Readable digests of a reasoning model's internal chain of thought, returned in place of the raw reasoning. OpenAI returns them when you set the reasoning summary parameter (auto picks the most detailed summarizer a model supports), and Claude returns them with display set to summarized. You are still billed for the full thinking tokens, not the shorter summary. Newer Claude models default to omitted, which returns an empty thinking field unless you ask for the summary.
Red Teaming
Red teaming means deliberately attacking a model or system to find harmful outputs and failure modes before real users or attackers do. Anthropic's 2022 study red teamed models from 2.7B to 52B parameters and found that RLHF-trained models got harder to red team as they scaled. It also released a dataset of 38,961 red team attacks. Labs now report red team findings when they launch models, and teams shipping agents run the same exercise against their own tools, permissions, and prompts.
Reinforcement Fine-Tuning (RFT)
Fine-tuning a model with reinforcement learning against a grader you define, instead of on fixed correct answers. The training loop samples several responses per prompt, scores each one with the grader, and shifts the weights so high-scoring outputs become more likely. OpenAI offers RFT as a managed API for its reasoning models, and teams run the same pattern themselves with GRPO on open-weight models. It works best when quality can be scored reliably, because a weak grader invites reward hacking.
Residual Connection
A shortcut that adds a layer's input straight to its output, so the layer only has to learn the change (the residual) instead of a whole new transformation. He et al. introduced it in ResNet in 2015 to make very deep networks trainable, and their ImageNet models went up to 152 layers. The Transformer puts a residual connection around every attention and feed-forward sub-layer, and the running sum of those outputs is often called the residual stream.
Responses API
OpenAI's current primary API for generating model output, designed as the successor to Chat Completions for agent-style applications. Inputs and outputs are typed Items, such as messages, function calls, and function call outputs, rather than a single message format. It includes built-in tools like file search, code interpreter, computer use, and remote MCP, and it can keep conversation state server-side through previous_response_id or the Conversations API. OpenAI recommends it for all new projects, while Chat Completions remains supported.
Responsible Scaling Policy
The Responsible Scaling Policy (RSP) is Anthropic's public framework for managing catastrophic risks as its models become more capable. It links capability thresholds, such as real uplift for chemical or biological weapons or the ability to automate AI research, to required safeguards called AI Safety Level standards. Anthropic must test models against those thresholds and upgrade its protections when a model crosses one. The policy is versioned: version 3.4 took effect on July 8, 2026.
Reward Hacking
Reward hacking is when a model trained against a reward finds a way to score highly without doing what the reward was supposed to measure. Concrete Problems in AI Safety (Amodei et al., 2016) named avoiding reward hacking as one of five core accident risks that come from a badly specified objective. In coding agents it shows up as special-casing tests, deleting failing assertions, or editing the grader instead of fixing the bug. The fix is a reward signal that is hard to game, plus checks that don't rely on the same signal.
Reward Model
A model trained to give a response a single score that predicts how much a human would prefer it. In the InstructGPT recipe, labelers rank several outputs for the same prompt, a reward model learns from those rankings, and the language model is then tuned with reinforcement learning to maximize that score. Because the policy chases whatever the reward model rewards, any flaw in the reward model shows up later as reward hacking or sycophancy.
RL Environments
The interactive setting a model acts in during reinforcement learning. It supplies observations, accepts the model's actions, and returns a reward plus a signal when an episode ends. OpenAI Gym standardized this reset-and-step interface in 2016, and its successor Gymnasium still defines it. For LLM agents, an environment is usually a sandboxed task, such as a repository with tests, a terminal, or a set of tools, paired with a verifier that scores the outcome.
RLAIF
Reinforcement Learning from AI Feedback: a variant of RLHF where an off-the-shelf LLM, not human annotators, labels which of two responses is better. A reward model is trained on those AI preferences and the policy is optimized against it. The idea comes from Anthropic's Constitutional AI work. In a 2023 head-to-head study, RLAIF matched RLHF on summarization and on helpful and harmless dialogue, trading expensive human labeling for cheaper AI judgment that can carry the labeler model's biases.
RLVR (Reinforcement Learning with Verifiable Rewards)
A reinforcement learning method that rewards a model only when its output passes a programmatic check, such as a math answer matching the reference, code passing unit tests, or a response meeting a stated constraint. The reward comes from a verifier instead of a learned reward model, so no human preference data is needed and the signal is harder to game. AI2 named the method in its Tulu 3 paper. The same idea drove DeepSeek-R1, whose reasoning skills came from RL on verifiable math and coding tasks.
RMSNorm
A normalization layer that rescales a vector of activations by its root mean square and then multiplies it by a learned gain. Zhang and Sennrich introduced it in 2019 as a simpler alternative to LayerNorm. It drops LayerNorm's mean-subtraction (re-centering) step, which they found was not needed, and their experiments showed similar quality with 7% to 64% less running time. Most modern open LLMs, including the Llama family, apply RMSNorm before each attention and feed-forward block.
RoPE (Rotary Position Embedding)
A way of encoding token positions in transformers by rotating each query and key vector by an angle proportional to its position. Introduced in the RoFormer paper (Su et al., 2021), it encodes absolute position while making attention scores depend on the relative distance between tokens, with that dependency decaying as distance grows. RoPE is widely used in open-weight LLMs, including the LLaMA family, and context-extension methods like YaRN work by rescaling its rotation frequencies.
Routing (Agent Pattern)
A workflow where an LLM or classifier first labels an incoming request, then sends it to a prompt, tool set, or model built for that category. Typical uses are splitting customer support traffic into general questions, refunds, and technical issues, or sending easy queries to a small, cheap model and hard ones to a more capable model. Routing works when the categories are distinct and easy to classify. A misrouted request goes down the wrong path, and nothing in the pattern brings it back.
Rubric-Based Grading
Scoring a model's output against an explicit, written rubric that defines what each score level means for each criterion, instead of asking for an open-ended quality rating. Rubrics make human and LLM-as-a-judge grading more consistent and let you score custom criteria like correctness, completeness, or readability separately. The Prometheus paper showed an open 13B evaluator given customized score rubrics reached a 0.897 Pearson correlation with human evaluators, on par with GPT-4.
RULER
A synthetic long-context benchmark from NVIDIA that measures how much of a model's advertised context window it can actually use. It extends the needle-in-a-haystack test with multiple needles and distractors, and adds multi-hop tracing and aggregation tasks at configurable sequence lengths. In the original study of 17 models, nearly all were close to perfect on plain needle retrieval yet dropped sharply as inputs grew, and only about half held up at 32K tokens despite claiming 32K or more.
S
Scaffold (AI)
The surrounding code and infrastructure that turns a raw language model into a useful application. A scaffold includes the prompt template, retrieval pipeline, tool definitions, output parsing, error handling, retry logic, and user interface. The model is the engine, but the scaffold is the car. Most of the engineering effort in AI applications goes into scaffolding, not model selection.
Semantic Search
A search method that finds results based on meaning rather than exact keyword matches. Semantic search works by converting text into vector embeddings and finding the closest vectors in a database. A search for 'how to fix a broken deployment' will find documents about 'troubleshooting production rollbacks' even though they share no keywords. Semantic search is the retrieval backbone of most RAG systems.
Skills (Claude Code)
Custom slash commands defined in markdown files that extend Claude Code's capabilities for specific workflows. Skills are stored in .claude/commands/ and can be project-specific or global. Each skill file contains instructions that Claude Code follows when the skill is invoked. Skills let teams codify common workflows - deployment procedures, code review checklists, content creation pipelines - as reusable, shareable commands.
Stdio Transport
The default communication method between MCP clients and servers. The client spawns the server as a child process and sends JSON-RPC messages over stdin/stdout. Stdio transport requires no network configuration, works entirely locally, and is the simplest way to connect an MCP server. It is used by Claude Code, Cursor, and most MCP clients for local development workflows.
Streaming
Delivering model output token-by-token as it is generated rather than waiting for the full response. Streaming improves perceived latency in chat interfaces and coding agents. The Vercel AI SDK and most provider SDKs support streaming responses out of the box.
Structured Output
Constraining a model to respond in a specific format - typically JSON matching a defined schema. Structured outputs eliminate parsing failures and make AI responses reliable enough to pipe directly into application logic. Zod schemas are commonly used to define the expected shape.
Sub-Agents
Lightweight AI agents spawned by a parent agent to handle a specific sub-task in parallel. Claude Code uses sub-agents (via the Task tool) to divide work - one sub-agent researches while another writes code - then the parent synthesizes the results.
Synthetic Data
Training data generated by AI models rather than collected from real-world sources. Synthetic data is used to augment scarce datasets, create evaluation benchmarks, train specialized models, and generate diverse examples for fine-tuning. High-quality synthetic data from capable models can train smaller models to punch above their weight. The risk is model collapse if synthetic data replaces real data entirely across training generations.
SWE-bench
A benchmark that evaluates AI coding agents on real-world software engineering tasks pulled from GitHub issues. Each task requires the agent to read a codebase, understand the bug or feature request, and produce a working patch. SWE-bench has become the standard measure for how well AI agents can do actual software development, not just isolated code generation.
System Prompt
Hidden instructions prepended to every conversation that define an AI model's behavior, personality, and constraints. System prompts set the rules that the model follows - like response format, tone, and what topics to avoid. CLAUDE.md files serve a similar purpose for coding agents.
Scaling Laws
Empirical relationships showing that a language model's loss falls as a predictable power law as you increase parameters, training data, and training compute. Kaplan et al. at OpenAI measured these trends across more than seven orders of magnitude and found that architectural details like width and depth matter far less than scale. Labs use scaling laws to forecast how a larger training run will perform and to decide how to split a fixed compute budget between model size and data.
Self-Consistency
A decoding strategy that samples several chain-of-thought reasoning paths for the same question and returns the final answer that appears most often. It replaces a single greedy reasoning path with a majority vote, on the intuition that different valid lines of reasoning tend to converge on the correct answer. The original Google paper reported gains such as +17.9% on GSM8K over standard chain-of-thought prompting. Unlike best-of-N, it needs no separate verifier, only answers that can be compared.
SimpleQA
A factuality benchmark from OpenAI that tests whether a model can answer short, fact-seeking questions that each have one indisputable answer. The questions were collected adversarially against GPT-4, and every response is graded as correct, incorrect, or not attempted. The scoring rewards a model that knows what it knows: the ideal model answers the questions it is sure of and declines the rest instead of guessing. Model cards often report it as a hallucination signal.
Small Language Model (SLM)
A language model small enough to run on a consumer device with low latency, in practice usually under about 10 billion parameters. Microsoft's Phi-3 report showed a 3.8B model could rival Mixtral 8x7B and GPT-3.5 on benchmarks while still fitting on a phone. NVIDIA researchers argue SLMs should be the default inside agentic systems, because agents repeat a narrow set of tasks where cost and latency matter more than broad conversation.
Softmax
A function that converts a vector of raw scores into probabilities between 0 and 1 that sum to 1, by exponentiating each score and dividing by the sum of all the exponentials. In a language model it turns the logits at each step into a probability distribution over the vocabulary. It is also used inside attention to turn relevance scores into weights. Temperature works by dividing the logits before softmax, which sharpens or flattens the resulting distribution.
Sparse Autoencoder (SAE)
A sparse autoencoder (SAE) is a small neural network trained to rewrite a model's internal activations as a sparse mix of many learned features, so each feature tends to stand for one interpretable concept. It addresses superposition: models pack in more concepts than they have neurons, so a single neuron ends up responding to many unrelated things. Anthropic's 2023 paper Towards Monosemanticity trained SAEs on the 512-neuron MLP layer of a one-layer transformer and extracted up to 131,072 features. Many of those features were far easier to interpret than individual neurons.
Special Tokens
Reserved tokens that mark structure rather than text, such as beginning-of-sequence (BOS), end-of-sequence (EOS), padding, and BERT-style [CLS] and [SEP] markers. Chat models add more, like <|im_start|> or <start_of_turn>, to show who is speaking and where a turn ends. The tokenizer inserts them automatically when it is set up to. Getting them wrong, by leaving out an EOS or adding a second BOS, quietly makes output worse or stops generation in the wrong place.
Speculative Decoding
An inference technique where a small, fast draft model proposes several tokens ahead and the large target model checks them all in one parallel forward pass. Tokens the target model agrees with are kept, and the first rejected one is resampled, so the output distribution is identical to running the large model alone. The original paper reported 2-3x speedups on T5-XXL without retraining or architecture changes. It works best when the draft model guesses well, such as on predictable code or boilerplate.
Speech-to-Text (ASR)
Automatic speech recognition, the task of converting spoken audio into written text. Modern ASR models are trained end to end on large amounts of paired audio and transcripts. OpenAI's Whisper, trained on 680,000 hours of multilingual audio, showed that this kind of weak supervision transfers zero-shot to standard benchmarks without fine-tuning. ASR is the first stage of most voice agents, dictation tools, and meeting transcription pipelines.
State Space Models (SSM)
State space models are sequence models that carry a fixed-size hidden state forward through the input, updating it with learned linear equations, rather than comparing every token to every other token like attention. That gives linear scaling with sequence length and constant memory per generated token. The S4 paper made SSMs efficient enough to compete on long-range benchmarks, and later work like Mamba brought them to language modeling.
Stop Sequences
Custom strings that tell a model to stop generating as soon as it produces one of them. In the Claude Messages API you pass them as stop_sequences, and when one matches, the response comes back with stop_reason set to "stop_sequence" and the matched string in the stop_sequence field. They let you cut output at a known delimiter, such as a closing XML tag, without paying for tokens you would throw away. Some compatible endpoints ignore the parameter, so check before relying on it.
Strict Mode (Tool Schemas)
A flag, strict: true, set on a tool or function definition that makes the model's tool arguments always conform to the declared JSON Schema instead of following it on a best-effort basis. It works through constrained decoding, so malformed or missing arguments are not sampled in the first place. OpenAI requires additionalProperties to be false on every object and every property to be listed as required when strict is on, and Anthropic offers the same guarantee for Claude as strict tool use. OpenAI recommends always enabling it.
Supervised Fine-Tuning (SFT)
Fine-tuning a pretrained model on curated prompt and response pairs so it learns to imitate the demonstrated answers. It uses the same next-token loss as pretraining, applied to high-quality examples. SFT is usually the first post-training step: OpenAI's InstructGPT fine-tuned GPT-3 on labeler-written demonstrations before applying RLHF. It is cheap and predictable for teaching format, style, and tool-call syntax, but it can only copy behavior already in the data, which is why reinforcement learning usually follows it.
SWE-bench Pro
A software engineering benchmark from Scale AI with 1,865 long-horizon tasks drawn from 41 actively maintained repositories, built as a harder successor to SWE-bench. Tasks often require multi-file patches that would take a professional engineer hours to days, and every task is human-verified. To resist training-data contamination, only 11 repositories are public, with the rest split into a held-out set and a commercial set of proprietary startup codebases.
SWE-bench Verified
A 500-task subset of SWE-bench that OpenAI released in August 2024 after 93 professional software developers screened the original test set. Annotators filtered out tasks with underspecified issue descriptions or unit tests that could reject valid fixes, so a failure is more likely to reflect the model than a broken task. It became the headline coding score in model launches, but because its tasks are public and Python-only, harder contamination-resistant successors like SWE-bench Pro now sit alongside it.
SWE-Lancer
An OpenAI benchmark of over 1,400 real freelance software engineering tasks from Upwork, together worth $1 million in actual payouts. It includes independent coding tasks, from $50 bug fixes to $32,000 features, graded by end-to-end tests that experienced engineers triple-verified, plus managerial tasks where the model picks the best of several implementation proposals. Scoring by dollars earned ties model performance to economic value, and the open evaluation split is called SWE-Lancer Diamond.
SwiGLU
SwiGLU is a gated activation used in the transformer feed-forward block: the input goes through two linear projections, one passed through the Swish function, and the two results are multiplied element-wise before the output projection. Noam Shazeer's 2020 paper tested several gated linear unit variants and found SwiGLU beat the usual ReLU and GELU activations. It has since become the default FFN activation in Llama and many other open models.
Sycophancy
Sycophancy is when a model tells users what they want to hear instead of the accurate answer, for example by agreeing with their stated views or backing down when they push back. A 2023 Anthropic study found that five state-of-the-art assistants were consistently sycophantic across four tasks. It traced part of the cause to human preference data, where responses that matched the user's views were more likely to be preferred. For developers, it looks like an assistant praising a flawed design or dropping a correct answer after a confident objection.
System Card
A system card is a detailed safety and capability report that a frontier lab publishes with a model release, extending the model card idea from the model to the whole deployed system. Anthropic says its system cards document the capabilities, safety evaluations, and deployment decisions for each Claude model, and OpenAI publishes similar documents for its releases. They usually cover benchmark results, red-teaming, misuse and alignment testing, and the safeguards applied. Caveats such as benchmark contamination or degraded behavior often appear there first.
T
Task Decomposition
The process of breaking a complex goal into smaller, manageable sub-tasks that an agent can execute individually. Good task decomposition is often the difference between an agent that succeeds and one that gets lost. Decomposition can be done by the user (explicitly listing steps), the agent (planning phase), or the framework (CrewAI tasks, LangGraph nodes). The quality of decomposition directly affects agent performance.
Temperature
A parameter (typically 0 to 2) that controls how random or creative a model's output is. Low temperature (0-0.3) produces focused, deterministic responses ideal for code generation. High temperature (0.7-1.5) produces more varied, creative outputs better for brainstorming.
Tokenizer
The component that converts raw text into tokens (and back) for a language model. Different models use different tokenizers with different vocabularies, which is why the same text produces different token counts across models. Understanding your tokenizer matters for cost estimation, context window management, and prompt optimization. BPE (Byte Pair Encoding) is the most common tokenization algorithm used by modern LLMs.
Token
The basic unit of text that LLMs process. A token is roughly 3-4 characters or about 0.75 words in English. Models have token limits for input (context window) and output (max completion). API pricing is typically measured per million tokens.
Tool Chaining
A pattern where an AI agent uses the output of one tool call as the input for the next, building a multi-step pipeline of actions. For example, an agent might search for a file (tool 1), read its contents (tool 2), modify the code (tool 3), and run tests (tool 4). Each step depends on the previous result. Tool chaining is the mechanism that turns single-tool agents into capable, multi-step problem solvers.
Tool Use
A model capability where the LLM can invoke external tools - running code, searching the web, reading files, calling APIs - as part of generating a response. Tool use turns a passive text generator into an active agent that can interact with the real world.
Top-K / Top-P Sampling
Two methods for controlling the randomness of model output during token generation. Top-K sampling limits the model to choosing from the K most likely next tokens. Top-P (nucleus) sampling limits the model to the smallest set of tokens whose cumulative probability exceeds P. Both work alongside temperature to balance creativity and coherence. Top-P 0.9 with temperature 0.7 is a common starting point for general text generation. Lower values produce more focused output.
Transfer Learning
The technique of taking a model trained on one task and adapting it for a different but related task. In AI, this usually means starting with a pre-trained language model (which learned general language understanding from massive text data) and fine-tuning it on domain-specific data. Transfer learning is why you do not need to train a model from scratch for every application. The pre-trained model already understands language; you just teach it your specific domain.
Transformer
The neural network architecture behind virtually all modern large language models. Introduced in the 2017 paper "Attention Is All You Need," transformers use self-attention mechanisms to process all tokens in a sequence simultaneously rather than one at a time. This parallelism makes them vastly more efficient to train than previous architectures like RNNs and LSTMs, and is the reason LLMs were able to scale to billions of parameters.
tau-bench
A benchmark from Sierra that tests agents in multi-turn customer-service conversations, where a language-model-simulated user talks to an agent that has domain API tools and a written policy to follow. The original domains are retail and airline, and each run is scored by comparing the database state at the end of the conversation with the annotated goal state. The paper also introduced the pass^k reliability metric. A follow-up, tau2-bench, adds a telecom domain where the user also has tools and the agent must guide them.
Tensor Parallelism
A model-parallel technique that splits the weight matrices inside each layer across several GPUs, so every GPU computes a slice of every layer and the partial results are combined with collective communication. Megatron-LM popularized it for transformers by partitioning attention heads and MLP matrices with only a few all-reduce operations per layer. Because GPUs synchronize on every layer, it needs a fast interconnect and is usually kept within one server, set in serving engines with options like vLLM's --tensor-parallel-size.
Terminal-Bench
A benchmark that measures how well AI agents complete hard, realistic tasks inside a computer terminal, inspired by problems from real developer workflows. Terminal-Bench 2.0 contains 89 tasks, each with its own environment, a human-written reference solution, and tests that verify the result. At launch, frontier models and agents scored under 65%, and the dataset and evaluation harness are published at tbench.ai.
Test-Time Compute
The computation a model spends while answering a prompt, as opposed to the compute spent training it. Spending more of it, through longer reasoning, sampling several answers, or searching against a verifier, can raise accuracy without changing the weights. A 2024 Google DeepMind and Berkeley paper found that allocating test-time compute adaptively by prompt difficulty let a smaller model outperform one 14x larger on some problems. Reasoning models and thinking budgets are the product form of this idea.
Text-to-Speech (TTS)
Software that converts written text into synthetic spoken audio. Neural TTS systems usually predict an intermediate acoustic representation such as a mel spectrogram from the text, then use a vocoder to turn it into a waveform. Google's Tacotron 2 established this two-stage design and reached quality ratings close to recorded human speech. TTS is the output stage of voice agents and is offered by most AI providers as an API.
Thinking Tokens
The tokens a reasoning model generates while working through a problem before it writes its final answer. OpenAI calls them reasoning tokens and Anthropic calls them thinking tokens, and both bill them as output tokens even when the raw reasoning is hidden or only shown as a summary. They also take up space in the context window. This is why the same prompt can cost several times more at a higher effort level with no change in the visible answer length.
Time to First Token (TTFT)
The time between sending a request and receiving the first output token. It generally includes request queueing, the prefill pass over the prompt, and network latency, so long prompts and busy servers both push it up. TTFT is what makes an interface feel responsive, and it is measured separately from generation speed because a model can be slow to start and fast once it streams, or the reverse.
Token Budget
A limit on how many tokens a model or agent may spend on a task, used to control cost and stop long runs from sprawling. Claude's task budgets apply this to agentic loops: you give the model one total covering thinking, tool calls, tool results, and output. The model then sees a running countdown so it can prioritize and wrap up cleanly. A task budget only guides pacing, while max_tokens stays the hard per-request cap that cuts off output when reached.
Token Counting
Measuring how many tokens a prompt will use before you send it, usually through a provider endpoint that runs the model's own tokenizer. Anthropic's /v1/messages/count_tokens accepts the same system prompt, tools, images, and PDFs as a real request, is free to call, and returns an estimate that can differ slightly from billed usage. Counts are tokenizer-specific: Anthropic notes Claude Opus 4.7 and later produce roughly 30 percent more tokens for the same text than earlier models, so recount when you switch.
Tokens per Second
A throughput measure of how many output tokens a model or serving system produces each second. Per-user tokens per second describes how fast a single response streams and approaches the inverse of inter-token latency on long outputs, while system tokens per second totals output across all concurrent requests. The two pull against each other: more concurrency raises system throughput but slows each individual stream, so check which one a benchmark reports.
Tool Search
A Claude API tool that lets the model discover and load tool definitions on demand instead of having every tool's schema in its context window from the start. You mark tools with defer_loading: true, and Claude searches the catalog by name and description, using either regex or BM25 variants, then loads only the few it needs. Anthropic reports this typically cuts tool-definition tokens by over 85 percent and keeps selection accuracy high, which otherwise degrades past 30 to 50 tools. It is especially useful for agents connected to many MCP servers.
Tree of Thoughts
A prompting framework that has a language model explore several intermediate reasoning steps ("thoughts") as branches of a tree instead of one linear chain. The model generates candidate thoughts, evaluates them itself, and uses search with lookahead and backtracking to decide which branch to pursue. In the original Princeton and Google DeepMind paper, GPT-4 solved 74% of Game of 24 puzzles with Tree of Thoughts versus 4% with chain-of-thought prompting.
TruthfulQA
A benchmark of 817 questions across 38 categories, including health, law, finance, and politics, written so that a common human misconception produces a confident wrong answer. It tests whether a model repeats false beliefs it absorbed from training text. In the original 2021 study, the best model was truthful on 58% of questions against 94% for humans, and larger models were generally less truthful.
U
Unsupervised Learning
A category of machine learning where models learn patterns from data without labeled examples or explicit correct answers. The model discovers structure on its own, such as clusters, correlations, or compressed representations. LLM pre-training is a form of unsupervised (or self-supervised) learning, where the model learns to predict the next token from massive amounts of unlabeled text.
V
Vercel AI Gateway
A single HTTP endpoint from Vercel that fronts hundreds of models from many providers behind one API key. You reference a model by a plain string like anthropic/claude-opus-4.8 or moonshotai/kimi-k2.5 and the request routes to the right provider, with automatic retries, embeddings, and spend monitoring across providers in one place. It is the default provider in the Vercel AI SDK when you pass a model as a string, and per its docs it adds no token markup, including with Bring Your Own Key.
Vector Store
A storage system purpose-built for saving, indexing, and querying vector embeddings at scale. Vector stores power the retrieval step in RAG pipelines by enabling fast similarity search across millions of embedded documents. Options range from hosted services (Pinecone, Weaviate) to database extensions (pgvector for PostgreSQL) to in-memory libraries (FAISS, Annoy). The choice depends on scale, latency requirements, and infrastructure preferences.
Vector Database
A database optimized for storing and querying high-dimensional vectors (embeddings). Vector databases like Pinecone, Weaviate, and pgvector enable fast similarity search, powering RAG pipelines, semantic search, and recommendation systems at scale.
Vibe Coding
A development approach where you describe what you want in natural language and let an AI agent handle the implementation details. The developer focuses on the overall direction and feel of the project rather than writing every line. The term was coined by Andrej Karpathy.
Verifier
A model or program that checks whether a candidate output is correct, used to score or filter what a generator produces. OpenAI's 2021 GSM8K paper trained a verifier to rank many sampled math solutions and pick the top one, and found this scaled better with more data than fine-tuning alone. Today verifiers include unit tests, proof checkers, and learned reward models, and they supply the reward signal for reinforcement learning on code and math, so a flawed verifier teaches the model to game it.
Vision-Language-Action Model (VLA)
A model that takes camera images and a natural-language instruction and outputs robot actions directly. Google DeepMind's RT-2 introduced the term by co-fine-tuning a vision-language model on robot trajectories, encoding each action as text tokens the model emits like words. Because the model keeps its web-scale pretraining, it can follow commands that never appeared in the robot training data. Gemini Robotics is a current example of the VLA approach.
Voice Agent
An AI agent that users talk to by voice, which listens, reasons, calls tools, and answers in speech. It is built either as a chained pipeline of speech-to-text, a text agent, and text-to-speech, or as a single speech-to-speech model that handles audio directly. Chained pipelines let you inspect and swap each stage, while speech-to-speech models cut latency and handle interruptions more naturally.
W
Window Sliding
A technique for processing text that exceeds a model's context window by moving a fixed-size window across the input, processing each chunk, and combining the results. In coding agents, window sliding lets the model work through large files section by section. In RAG systems, overlapping windows during chunking ensure that no information is lost at chunk boundaries. The overlap size (typically 10-20% of the window) is a key parameter.
Weights
The numerical parameters inside a neural network that are learned during training. Weights determine how the network transforms input into output. When people say a model has 70 billion parameters, they mean 70 billion weights. Releasing model weights publicly is what makes open-source AI models possible, since anyone with the weights can run inference without depending on an API provider.
Worktrees (Claude Code)
A git feature that Claude Code uses to run multiple agents on separate branches simultaneously without conflicts. Each worktree is a separate working directory linked to the same repository, letting agents work on different features in parallel and merge results back.
World Model
A learned model of an environment that predicts how it will change in response to actions, letting an agent simulate outcomes before acting. Ha and Schmidhuber's 2018 paper trained a generative model to compress an environment into a latent representation, then trained a policy entirely inside the model's own simulated "dream" and transferred it back to the real environment. The term now also covers large video and multimodal models pitched as general simulators of the physical world for robotics and interactive generation.
Y
YaRN
YaRN (Yet another RoPE extensioN method) is a technique for extending the context window of RoPE-based models beyond the length they were pretrained on. It combines "NTK-by-parts" interpolation, which stretches the low-frequency rotary dimensions while leaving high-frequency ones alone, with a temperature adjustment on the attention logits. The paper reports needing 10x fewer tokens and 2.5x fewer training steps than earlier methods, and open-weight families such as Qwen document it as the way to run past their native context length.
YOLO Mode
YOLO mode is the informal name for running a coding agent with every permission prompt turned off, so file edits and shell commands run without asking for approval. In Claude Code it is the --dangerously-skip-permissions flag, which is the same as the bypassPermissions permission mode. Gemini CLI ships a flag literally called --yolo that auto-approves all tool calls. Claude Code's docs say to use it only in isolated environments like containers or VMs without internet access, because it gives no protection against prompt injection or unintended actions.
Z
Zero-Shot Learning
A model's ability to perform a task it was not explicitly trained on, using only the instructions in the prompt with no examples. When you ask a model to classify sentiment, translate text, or summarize an article without providing any examples, that is zero-shot learning. Modern LLMs are remarkably capable zero-shot learners because their broad training lets them generalize to new tasks from instructions alone. When zero-shot performance is insufficient, adding examples (few-shot learning) usually closes the gap.
Zod (Schema Validation)
A TypeScript-first schema declaration and validation library. In AI development, Zod defines the shape of structured outputs from LLMs, validates API payloads, and ensures type safety at runtime. It is the standard schema tool in the Vercel AI SDK and most TypeScript AI stacks.
Put these concepts to work
Get Smarter About AI Dev
New tutorials, open-source projects, and deep dives on coding agents - delivered weekly.
One email per weekReal code, not theoryFree forever