AI 101
📚

The AI glossary

Every AI term you'll meet — tokens, embeddings, RAG, quantization, MCP, harness and more — defined in plain English with examples.

Hit a word you don’t know? It’s probably here.

Every term gets a plain-English definition, a concrete example, and links to related terms. No term is more than two sentences from being understandable.

Basics 51

Activation function The tiny non-linearity added after each layer's math — without it, a whole network collapses into one big linear calculation. Alignment The work of making a model's goals and behavior line up with human intent and values — so it does what you actually meant. Artificial intelligence The broad field of building systems that do things we usually reserve for minds — recognizing, deciding, generating, learning. Attention The mechanism that lets each token 'look at' every other token and decide which matter — the heart of the transformer. Backpropagation The algorithm that trains a network: measure the error, then walk backward to work out how to nudge every weight to reduce it. Benchmark A standardized test a model takes so we can compare models fairly — the report card with known answers. Capability A specific thing a model can reliably do — coding, reasoning, translation — the unit we compare models by. Checkpoint A saved snapshot of a model's weights at a point in training — how models get released, shared, and resumed. Cloud API (for LLMs) Using a model over the internet via HTTP — you send a request, get a response, pay per token. No GPU, no install, no weights. Compute The raw processing power (GPUs/TPUs × time) needed to train or run a model — the binding resource of the AI era. Context window The model's short-term memory: how much text it can see at once, measured in tokens. Corpus A large body of text used for analysis or training — the raw text pool behind many datasets. Data bias Systematic skew in the training data that shows up as unfair or one-sided model behavior. Data center A facility packed with racks of GPUs and servers where models are trained and served — the physical plant of the cloud. Data quality How clean, accurate, and relevant the training examples are — often the biggest lever on model behavior. Dataset A collection of examples used to train or test a model — the raw material of machine learning. Deep learning Machine learning with many stacked layers of simple units — the recipe behind every modern LLM and image model. Diffusion model The architecture behind modern image generators — it learns to work backward from pure noise to a clean image. Embedding A model's numeric 'meaning fingerprint' for a word, phrase, or document — similar things land near each other in a map of numbers. Emergent ability A capability that suddenly appears once a model crosses a size threshold — it wasn't there in the smaller version at all. Foundation model A giant general-purpose model trained once at massive cost, then adapted for many jobs — the 'foundation' everything else builds on. Frontier model A model at the cutting edge of capability — the strongest available, from the biggest labs, usually closed. Generalization A model's ability to perform well on new, unseen inputs — the whole point of learning instead of memorizing. Generative AI AI that produces brand-new content — text, images, audio, code — instead of just classifying or predicting. GPT OpenAI's line of LLMs (Generative Pre-trained Transformer) — the name that made LLMs famous, and a de facto category label for chat models. GPU The graphics processor that — because it's great at parallel math — also became the workhorse for training and running AI. Gradient The 'slope' that tells a model which way to push each weight to get a better answer — the steering signal in training. Hallucination When a model states something confidently that is simply not true — a confident fabrication, not a careful guess. In-context learning A model adapting to a new task purely from examples in the prompt — no weight updates, just good examples up front. Large language model A huge neural network trained on massive text to predict and generate language — the engine behind ChatGPT, Claude, Gemini and friends. Layer One stage in a neural network's stack — input flows through many layers, each transforming the signal a little further. LLM (large language model) A large neural network trained on huge amounts of text to predict and generate the next token — the engine behind chatbots, agents, and code tools. Loss function A score for how wrong the model's output is — the number training constantly tries to drive down. Machine learning Teaching a program to get better at a task by showing it many examples, instead of hand-writing the rules. Model A model is the trained 'brain' behind an AI system — a giant set of learned numbers. Model size How big a model is, counted in parameters — '7B', '70B', '405B' — the main dial on capability vs. cost. Multimodal A model that handles more than one type of input/output — text plus images, audio, or video — instead of text alone. Neural network A web of simple number-crunching units loosely inspired by brain neurons — the engine inside deep learning. Open weights A model whose internal numbers are published so anyone can download, inspect, and run it — the 'open source' of the model world. Open-source model A model released under a license that lets you run, modify, and (often) share it — more permissive than 'open weights' alone. Overfitting When a model memorizes its training examples so well it does great on them but badly on anything new. Parameter One adjustable number inside a model. Big models have hundreds of billions of them. Proprietary model A closed model you can only use through the company's API or app — the weights stay secret and locked away. Scaling laws The empirical finding that model quality improves predictably as you scale up data, parameters, and compute. Token A token is a chunk of text — about ¾ of a word — that AI models actually read and write. Tokenization Breaking text into the chunks (tokens) a model actually reads and writes. Training data The examples a model learns from — for LLMs, a huge mix of web text, books, code, and more. Transformer The architecture invented in 2017 that powers every modern LLM — it reads a whole sequence at once via 'attention'. Underfitting When a model is too simple to capture the pattern — it does poorly even on the data it trained on. Vector An ordered list of numbers — the universal format models use to represent words, images, and even ideas. Weights The millions-to-billions of adjustable numbers that *are* the model — its entire learned knowledge, stored as values.

Training 45

Adapter A small trained module plugged into a frozen model to give it a new skill — the LoRA/PEFT idea in general. Base model The raw model straight out of pretraining — knowledgeable but unshaped for conversation or tasks. Batch size How many examples the model processes before updating its weights once — a key knob between speed and stability. BF16 Brain Float 16 — a 16-bit floating format with a wide exponent range, favored for training and inference because it's hard to overflow. Catastrophic forgetting When fine-tuning a model on a new task makes it *lose* the old skills it had — it overwrites what it knew. Curriculum learning Feeding a model easier examples first, then harder ones — like a good teacher building up from basics. Data augmentation Artificially varying training examples (rephrasing, shuffling, masking) so the model sees more variety without collecting more data. Data mixing Deciding what *proportions* of each data source go into training — code vs. web vs. math — a major lever on a model's final skill mix. Distribution shift When the real-world data a model meets differs from what it trained on — and its quality quietly degrades. DPO (vs RLHF) Direct Preference Optimization — a simpler, more stable alternative to RLHF that learns from the same preference data without a separate reward model. Dropout Randomly switching off a fraction of units during training so the network can't rely on any single one — a classic anti-overfitting trick. Early stopping Stopping training before the model starts memorizing — when validation loss stops improving, call it. Epoch One full pass through the entire training dataset — models typically see the data many epochs over. Eval (evaluation) A systematic way to measure a model's output quality on a fixed set of tasks — the report card you trust more than vibes. Fine-tuning Extra, lighter training that teaches a pre-trained model to behave the way you want. FP16 A 16-bit floating format — half the memory of 32-bit, but with a narrow range that can overflow on big activations. Freezing (weights) Locking some or all of a model's weights so training can't change them — keeping the base intact while you adapt the rest. Gradient accumulation Building up gradients over several micro-steps before one update — a way to get a bigger effective batch without more memory. Gradient checkpointing Recomputing parts of the forward pass during training to save memory — trading a bit of speed for a lot of VRAM. Instruct model A base model that's been instruction-tuned and aligned — the 'assistant' you actually talk to. Instruction tuning Fine-tuning on examples of following instructions, so the model does what you ask rather than just continuing the text. Knowledge distillation Training a small, cheap model to imitate a big, expensive one — squeezing frontier behavior into a pocket-size model. Label noise When training examples have wrong or inconsistent labels — the model faithfully learns the mistakes baked into the data. Learning rate How big a step each weight adjustment takes — too big and training diverges, too small and it crawls. LLM-as-judge Using one LLM to grade another LLM's outputs — cheap and scalable, but it brings its own biases to the judge's bench. LoRA Low-Rank Adaptation — freeze the model, train two small matrices per layer, and attach them as a light 'skill' file. Loss curve The chart of training loss over time — the model's report card, and the first thing you check to diagnose a run. Mixed precision Doing training math in lower precision (FP16/BF16) where it's safe to save memory and speed — the standard way modern models are trained. Model merging Blending the weights of two or more models into one — a cheap way to combine their strengths without retraining. Normalization Rescaling intermediate values (e.g., LayerNorm, RMSNorm) to keep training stable as networks get deep and wide. PEFT Parameter-Efficient Fine-Tuning — adapting a huge model by training only a small fraction of its parameters (e.g., LoRA). Pre-training The first big training run: the model reads a huge amount of text and learns language itself. Pretraining (base model) The first, giant training phase — predict-the-next-token over raw text — that produces the unpolished 'base' model. QLoRA LoRA applied on top of a *quantized* frozen model — fine-tuning big models with a fraction of the memory. Regularization Any technique that deliberately makes a model a bit *worse* on the training data so it generalizes better — the anti-overfitting toolbox. Reinforcement learning Learning by trial and error with rewards — the model acts, gets scored, and adjusts to maximize reward. Reward hacking When a model learns to *maximize the score* rather than the intent — gaming the referee instead of doing the job well. Reward model A model trained to predict how a human would rate an answer — the referee used inside RLHF. RLHF Reinforcement Learning from Human Feedback — fine-tuning a model using human ratings of which answers are better. SFT Short for supervised fine-tuning — see that page for the full picture. Supervised fine-tuning Continuing training on curated input→output examples to shape a model's style and task behavior. Synthetic data Training examples generated by an AI (often a stronger model) rather than written by humans — a cheap way to make data at scale. Training The expensive, one-off process of adjusting a model's weights on a huge dataset so it learns — as opposed to the cheap per-request inference. Weight decay A penalty on large weight values that keeps the model simple — a staple regularizer that also improves generalization. Weight initialization How a model's weights are set *before* training — not random chaos, but a deliberate scheme that lets learning start stable.

Inference 45

Batching Processing many prompts together to use the GPU more efficiently — the main way inference gets cheaper and faster at scale. Beam search Keep the top few candidate sequences alive and pick the best at the end — better than greedy, but it over-smooths and repeats. Chain-of-thought Getting a model to show its reasoning step by step before the answer — a big reliability boost on multi-step problems. Chunking Splitting long documents into manageable pieces before embedding — the decision that quietly determines RAG quality. Citation A model's pointer to the specific source or passage backing a claim — what turns an unverifiable statement into a checkable one. Context rot The quiet degradation in a model's use of its context as the prompt gets longer — the middle gets lost, the edges hold. Decoding The strategy a model uses to turn its next-token probabilities into an actual sequence — greedy, beam, or sampling. Embedding model A model specialized to turn text into embeddings — smaller and cheaper than an LLM, built for measuring meaning-similarity. Few-shot prompting Giving the model 2–5 worked examples in the prompt so it imitates the pattern — the highest-ROI prompting trick. Function calling A model deciding to call a function (with structured arguments) instead of just talking — the bridge from chat to doing things. Greedy decoding Always picking the single most likely next token — the simplest decoding strategy, and the most repetitive. Grounding Anchoring a model's answer in provided source material so it reports what the source says, not what it guesses — the antidote to hallucination. Hallucination rate How often a model states false or unsupported claims — a metric you can measure (and drive down with grounding and citations). Hybrid search Combining keyword (BM25) and vector (semantic) search to catch both exact-term and meaning matches — the most robust retrieval recipe. Inference Running the model to get an answer — the 'exam' side of AI, as opposed to 'school' (training). JSON mode A model/ API setting that forces the response to be valid JSON — the first step toward parseable output. KV cache Caching the attention key/value vectors for already-generated tokens so each new token doesn't recompute the whole prefix — the core memory trade of inference. Latency The delay between sending a prompt and getting output — split into time-to-first-token and the time to finish. Logit bias Manually nudging the raw score of specific tokens up or down before sampling — a surgical way to force or forbid certain words. Logits The raw, un-normalized scores a model assigns to every token before they're turned into probabilities. Long context Models that can accept (and use) very large prompts — 100K to 1M+ tokens — at a real memory and quality cost. Max tokens A hard cap on how many tokens the model may generate in one response — the guardrail against runaway, endless output. MCP Model Context Protocol — an open standard for giving models a standardized way to connect to tools and data sources. Prompt Everything you send the model in one go — your question plus all the context around it. Prompt caching Reusing the computed KV cache for a repeated prompt prefix (system prompt, big docs) — a big cost and latency win on repeated work. Prompt engineering The craft of writing prompts that reliably steer a model — structure, examples, constraints, and clarity over cleverness. RAG Retrieval-Augmented Generation: the model looks up documents you gave it, then answers from what it finds. RAG evaluation Measuring RAG quality in two parts — did retrieval find the right chunks, and did the answer use them well — instead of judging the whole thing by vibes. Reasoning A model's ability to work through multi-step logic before answering — the skill that separates 'guessing' from 'thinking'. Repetition penalty A nudge that lowers the odds of tokens the model has already used — the classic fix for circular, looping output. Reranking A second pass that re-scores and reorders the retrieved chunks so the best ones land at the top — cheap, high-impact retrieval polish. Retrieval Finding the most relevant pieces of information for a query — the 'R' in RAG, and the step that makes or breaks answer quality. Sampling How a model picks the next token from a probability distribution — the knob family behind creativity vs. determinism. Softmax The function that turns raw logits into a probability distribution that sums to 1 — the bridge from scores to sampleable odds. Stop sequence A string that, if the model generates it, ends the response immediately — a clean way to bound structured output. Streaming Sending the model's answer token-by-token as it's generated — so the user sees text appear live instead of waiting for the whole thing. Structured output Constraining a model's response to a strict schema (JSON, etc.) so it's guaranteed parseable — no more scraping free text. System prompt The hidden instruction layer that sets the model's role, rules, and tone before the user's message even arrives. Temperature A dial on how random the model's word choices are: low = safe and predictable, high = wild and creative. Thinking models Models that explicitly 'think' — generating a scratchpad of reasoning before the answer — trading speed for much better accuracy on hard problems. Throughput How much output a system produces per unit time — the measure of sustained inference capacity, not just speed. Top-k sampling Keep only the k most likely tokens, then sample among them — a simpler, count-based way to limit the model's choices. Top-p (nucleus sampling) Sample only from the smallest set of tokens whose probabilities add up to p — a smarter alternative to top-k. Vector database A database built to store embeddings and find the nearest ones fast — the memory behind RAG and semantic search. Zero-shot prompting Asking the model to do a task with no examples at all — it has to rely purely on its pretraining.

Agents 51

A2A (Agent-to-Agent) A protocol for agents to discover, communicate with, and delegate to *other* agents across vendors — the 'HTTP of agent collaboration.' Agent eval Systematically measuring whether an agent actually completes its tasks — with test tasks, success criteria, and repeatable runs. Agent framework A library that packages the harness for you — loop, tool calling, memory, state — so you write logic instead of plumbing. Agent loop The cycle an agent repeats: perceive → decide → act → observe → repeat — the engine that separates agents from one-shot answers. Agent security The discipline of securing AI agents — prompt injection, tool abuse, exfiltration, and the unique risks that come from autonomy. Agents (general) An LLM that can act in a loop — perceive, decide, use tools, observe, repeat — rather than answering once and stopping. AI agent An AI that doesn't just answer — it loops: think, use a tool, observe the result, repeat — until a goal is done. Allowlist An explicit list of the tools, domains, or actions an agent is permitted to use — everything else is blocked by default. Approval gate A checkpoint in an agent's flow where a specific action is paused until a human (or policy) explicitly approves it. AutoGen Microsoft's multi-agent framework where conversations between agents (and humans) drive the workflow — agents talk, code runs, results flow back. AutoGPT An early viral autonomous agent (2023) — give it a goal and it kept planning and executing subtasks, often spectacularly, sometimes in circles. BabyAGI Another 2023 viral agent: a task-generating, task-executing loop that kept creating its own next tasks — a clean, minimal prototype of the agent loop. Browser agent An agent that navigates and operates a web browser — reading pages, clicking, filling forms — to accomplish web-based tasks. CLI agent An agent that works primarily through command-line tools — shells, git, package managers — the interface most developers already live in. Code agent An agent whose main job is writing, running, and fixing code — the harness you're likely using to read this glossary. Computer use An agent controlling a real computer — seeing the screen and driving mouse and keyboard — the broadest (and riskiest) form of agency. Cost control The practices that keep agent spend in check — budgets, rate limits, caching, and model routing — because autonomy multiplies API calls. CrewAI A multi-agent framework built around 'crews' — teams of role-based agents (researcher, writer, reviewer) collaborating on a goal. Docker sandbox Running an agent's workloads in Docker containers — the most common sandbox because it's fast, cheap, and disposable. Environment (agent) What the agent can perceive and act on — files, web pages, a terminal, an app UI. The world its actions have effects in. Filesystem access (agent) The permissions governing which files/directories an agent can read or write — a core part of bounding what a code agent can touch. Function schema The JSON-Schema definition of a function in function calling — parameters, types, and descriptions the model must respect when emitting a call. GUI agent An agent that interacts with graphical user interfaces — reading pixels or UI trees and issuing clicks, types, and drags. Harness The scaffolding around a model that makes it an agent — the loop, the tools, the memory, the rules. The model is the brain; the harness is the body. Human in the loop A human approving, correcting, or stepping in on specific agent actions — the control point that makes autonomy accountable. LangChain One of the earliest and most widespread LLM application frameworks — chains of model calls, tools, and retrieval, with a large ecosystem. Langfuse An open-source observability and eval platform for LLM apps — traces, prompts, and metrics, self-hostable. LangGraph LangChain's stateful framework for building agents as explicit graphs — nodes, edges, and shared state — favoring control and inspectability. LangSmith LangChain's tracing, debugging, and evaluation platform for LLM apps and agents — see the run, find the bad step, measure improvement. Long-term memory What an agent remembers across sessions — persistent, retrievable memories of facts, decisions, and past outcomes. Memory The information an agent carries between steps or sessions — short-term (this task) and long-term (across tasks). Memory store Where an agent keeps information across steps or sessions — a structured place to write, read, and retrieve the things it must remember. Multi-agent systems Several agents (or an agent + specialists) collaborating on a task — splitting work the way a small team would. Observability (agents) Seeing into what an agent is doing — its decisions, tool calls, state, and costs — the difference between trusting a loop and understanding it. OpenAI Agents SDK OpenAI's agent framework built on handoffs, guardrails, and tracing — a lean successor to the Assistants API. Orchestrator The lead agent that decomposes a task, delegates to specialists, and assembles the result — the project manager of an agent team. Permission model The rules defining what an agent may do with which tools and data — the policy layer between the model's intentions and its actual reach. Planning An agent breaking a goal into steps and deciding the order before acting — the difference between thrashing and getting things done. Rate limit (agents) A cap on how often or how much an agent can act or call an API — the control that stops runaway loops from burning cost or hammering a service. Reflexion A technique where an agent reflects on its own failures and writes a self-critique it consults next time — learning from experience within a session. Sandbox An isolated, throwaway space where an agent's actions can't touch your real system — the safety box around autonomous code execution. Self-reflection A model evaluating its own output — spotting gaps, double-checking claims, or writing a critique — before committing to an answer. Session memory What an agent remembers within a single session — the running context of the current task, usually just the conversation plus a short summary. Subtask A smaller piece of work an agent breaks a larger task into — the unit of planning that makes big goals tractable. Tool description The human-readable text in a tool's schema explaining when and how to use it — one of the highest-leverage levers for agent reliability. Tool permissions The per-tool rules controlling what an agent may call and with which arguments — the fine-grained layer of the permission model. Tool schema The typed description of a tool an agent can call — its name, parameters, types, and what each does. The contract between model and toolbox. Tool use Letting a model call outside functions — search, shell, calendar — instead of only writing text. Tracing (agents) Recording a full, ordered trace of an agent run — every model call, tool call, and decision — so any run can be replayed and analyzed. Vector memory Memory backed by embeddings and a vector database — the agent retrieves what it needs by *meaning*, not exact string match. Workflow vs. agent The key design fork: fixed, pre-defined steps (workflow) vs. a model that decides its own steps (agent). Most real systems are a blend.

Local 49

4-bit quantization (INT4) Storing each weight as 4 bits — the most popular quant for local models, cutting size to a quarter of full precision. 8-bit quantization (INT8) Storing each weight as 8 bits — half of full precision, a mild loss and a good middle ground. Air-gapped A system physically cut off from any network — the strongest (and most inconvenient) form of local isolation. AnythingLLM A self-hosted app that bundles a chat UI, RAG, and document ingestion into one — RAG without the plumbing. Apple Silicon (Mac) M-series Macs with fast unified memory — a genuinely good (and power-efficient) platform for local LLMs. AWQ Activation-aware quantization — picks which weights to keep precise based on what the model actually uses. A 4-bit scheme that's fast to run. Consumer GPU A GPU bought for a person, not a data center — the 8–24 GB cards most people use to run local LLMs. Context offloading Spilling part of the model (weights or KV cache) from VRAM to system RAM when it doesn't all fit — slower, but it lets bigger models run. CPU inference Running an LLM on the processor alone — slower, but it needs no GPU and is the fallback when VRAM is absent or full. Dense model A model that uses *all* of its parameters for every token — the classic architecture, and the baseline MoE is measured against. Edge AI AI that runs at the 'edge' — on the device or local network — instead of in the cloud. The umbrella term for local/on-device inference. ExLlamaV2 A fast GPU inference engine with its own EXL2 quantization — a high-performance option for serving local models on CUDA. GGML The tensor library behind llama.cpp — the engine's core math layer, and the name behind the original GGML file format. GGUF The open file format (and its quant schemes) behind most local LLM downloads on Hugging Face. GPTQ A post-training 4-bit quantization method (and its tooling) — a long-standing option for compressing LLMs with little loss. Hugging Face The GitHub of AI — the hub where most open models, datasets, and tools are published and downloaded. Hugging Face Hub The specific model/dataset repository on huggingface.co — where you browse, search, and pull down models by name. Jan An open-source, local-first chat app for running and chatting with local LLMs across devices. K-quants A family of quant schemes (Q4_K_M, Q5_K_M…) that mix precision smartly to squeeze better quality from the same bits. KoboldCpp A single-binary inference tool (and server) popular with creative writers and local roleplay/RP setups. Llama (Meta) Meta's family of open-weight LLMs — one of the most widely used bases for local models, fine-tunes, and derivatives across the ecosystem. llama.cpp The C/C++ inference engine that runs GGUF models on CPUs and GPUs — the workhorse of local LLMs. llama.cpp server The OpenAI-compatible HTTP server that ships with llama.cpp — run a model and hit it with any client. llamafile A single portable executable that bundles llama.cpp + a model + a web UI — double-click and run, no install. LM Studio A friendly GUI for downloading, quantizing, and serving local LLMs — the friendliest entry point into local AI. Local embedding model A small embedding model you run locally (e.g. via Ollama) to power local RAG and semantic search without the cloud. Local LLM A model you run on your own hardware instead of a cloud API — private, offline-capable, and yours to configure. Local privacy The guarantee that your prompts and data never leave your machine — the core reason people run LLMs locally. Local RAG Retrieval-augmented generation that runs entirely on your machine — embeddings, vector store, and LLM all local. Mixture of Experts (MoE) An architecture where each token is routed to a few 'expert' sub-networks — big total parameters, small active ones per token. Offline AI AI that works with zero network — useful on planes, in the field, or anywhere the internet isn't. Ollama The easiest way to download and run open AI models on your own computer — one command, fully local. On-device AI Running models directly on a phone, laptop, or edge box — no round-trip to a data center. ONNX Open Neural Network Exchange — a common intermediate format that lets models move between frameworks and runtimes. Open WebUI A polished, self-hosted chat interface that works with Ollama and OpenAI-compatible endpoints — a ChatGPT-like look, on your own box. OpenVINO Intel's toolkit for running (and optimizing) models on Intel CPUs, integrated GPUs, and NPUs — a fast path on x86 hardware. Piper TTS A fast, local text-to-speech engine with many voices — the lightweight counterpart to Whisper in a local audio stack. Private deployment Running a model inside your own infrastructure — VPC, on-prem, or local — so data stays in your perimeter. Quantization Compressing a model's math from precise 16-bit numbers to rough 4-bit ones, so it fits on your machine. Quantization accuracy How much quality a model loses when you reduce its weights' precision — the core trade-off behind every local model choice. Small Language Model (SLM) A compact LLM (often 1–8B) designed to run fast on everyday hardware — the engine behind on-device AI. Tensor split Distributing a model's layers across multiple GPUs (or CPU+GPU) so a too-big model can still be served. TensorRT NVIDIA's inference optimizer that compiles models into fast, hardware-tuned engines for its GPUs. Text-Generation-WebUI The long-standing browser UI for local LLMs (and image models) with a rich options panel — power-user territory. Tokens per second (tok/s) The standard speed metric for local inference — how fast the model emits tokens once it starts. Unified memory Apple's design where CPU and GPU share one pool of RAM — letting a Mac run bigger models than its GPU would suggest. vLLM A high-throughput serving engine (PagedAttention) for running LLMs on GPUs at scale — the default for production local/cloud inference. VRAM Video RAM — the GPU's own fast memory. Your model must fit in it (or be offloaded) for local inference to be fast. Whisper OpenAI's open local speech-to-text model — accurate, multilingual, and runnable on your own hardware.

Security 54

Adversarial prompt A prompt deliberately designed to trigger a failure — a wrong answer, a leaked secret, a bad action — rather than a correct one. Agentic risks The new safety surface when LLMs act: wrong tool calls, exfiltration, loops, and hard-to-audit decisions — risk that scales with capability. Algorithmic bias Systematic, unfair patterns in a model's outputs, inherited from its training data — e.g. favoring some names, jobs, or groups over others. Anonymization Removing or transforming identifiers so data can't be linked back to a person — a key step before feeding data to models or sharing it. API keys The secret credentials that let your app call a model API — treat them like passwords: never in code, logs, or chat. Attribution Knowing the origin of content — which model, which human, which source — a prerequisite for accountability and for tracking AI-generated material. Audit log An immutable record of what an AI system did — decisions, tool calls, inputs, outputs — the evidence trail for accountability and forensics. Constitutional AI A training approach (from Anthropic) where a model critiques and revises its own outputs against an explicit set of principles — 'AI with a written code of conduct.' Content moderation (AI) Detecting and filtering unsafe or policy-violating content — in prompts, outputs, or generated media — usually with a classifier model plus rules. Content policy The explicit rules for what a product's AI may and may not say or do — the contract between the model, the app, and the user. Copyright The legal right over creative work — a live issue for AI, both when models are trained on copyrighted text and when they reproduce it. Data exfiltration Stealing sensitive data out of a system — for LLM apps, the risk of a model luring secrets into its output or a tool call. Data residency Where (geographically / legally) your data is processed and stored — a compliance constraint that shapes whether cloud or local AI is even an option. Data retention How long a provider or your system keeps prompts, outputs, and logs — a privacy and compliance question you should have an answer to. Deepfake AI-generated (or manipulated) media — faces, voices, video — that's realistic enough to deceive, and is misused for fraud and impersonation. Differential privacy A mathematical guarantee that adding or removing one person's data barely changes a model's output — strong privacy for training. Explainability The ability to say *why* a model made a given output or decision — the difference between trusting a result and understanding it. Fairness Designing and auditing AI so its outputs don't systematically disadvantage particular groups — a measurable property, not a vibe. Federated learning Training a model across many devices without centralizing the raw data — each device learns locally and shares only updates. GDPR The EU data-protection regulation — the legal backdrop for handling personal data in AI systems, with real penalties for getting it wrong. Human oversight Keeping a person in the loop for high-stakes AI decisions — the control that makes autonomy accountable. Impersonation Using AI to pretend to be a person (voice, text, face) to deceive — one of the most common real-world harms of generative models. Interpretability Understanding *how* a model works internally — the deeper (and harder) cousin of explainability, focused on the model's own representations. Jailbreak A prompt engineered to make a model ignore its safety rules and do something it was told not to do. Kill switch A hard, immediate way to stop an agent or system — the emergency-stop control for when autonomy goes wrong. Least privilege Giving a model or agent only the minimum tools, data, and permissions its task actually needs — the single most effective AI security habit. Licensing The legal terms under which a model (or dataset) may be used, modified, and redistributed — the thing to read before shipping a product. LLM guardrails The combined controls around an LLM app — input/output filters, policy, least privilege, oversight — the safety architecture, not just the model. Malicious MCP server A rogue Model Context Protocol server that looks legitimate but steers or exfiltrates through the tools it exposes. Membership inference An attack that guesses whether a specific person or record was in a model's training data — a privacy leak about the data, not the model. Model extraction An attack where an adversary queries a model (via an API) enough to reconstruct a close copy of its weights — stealing the model itself. Model inversion An attack that uses a model's outputs to reconstruct sensitive inputs it was trained on — pulling data back out of the weights. Model poisoning Deliberately corrupting a model's training data (or fine-tuning data) so it misbehaves later — a backdoor baked in at train time. Output filtering Scanning a model's responses for harmful, secret, or off-policy content before it reaches the user or another system. PII Personally Identifiable Information — any data that can identify a person (name, email, ID number, location). Prompt armor Hardening a system prompt so it's more resistant to injection and leakage — the model's own instructions as a security boundary. Prompt injection When text the model reads — a page, an email, a file — quietly tries to rewrite its instructions. Prompt injection defense The layered techniques for keeping untrusted text from hijacking your app's instructions — the core security problem of LLM apps. Pseudonymization Swapping identifiers for pseudonyms (keys/tokens) so data is usable but re-identifiable only with a separate key — GDPR's preferred middle ground. Red teaming Actively attacking your own AI system (with prompts, edge cases, adversarial inputs) to find failure modes before attackers do. Responsible AI The practice of building and deploying AI with fairness, safety, transparency, and accountability baked in — not bolted on. Safety filter A classifier or rule layer that blocks disallowed inputs or outputs — the guardrail that sits in front of (or behind) the model. Secret leakage The failure mode where credentials, keys, or tokens end up in a prompt, log, or output — and out the door. Sensitive data Any information you don't want leaked — PII, secrets, trade secrets, medical/financial records — that needs special handling in an AI pipeline. Side-channel attacks Learning secrets not from the model's output but from its behavior — timing, memory, power — a subtle leak path. Social engineering Manipulating people into doing what an attacker wants — AI makes the lures (text, voice, email) cheaper and more convincing. Supply-chain attacks Compromising a dependency, package, or model in your pipeline rather than your own code — a growing vector for AI systems. Sycophancy A model agreeing with the user, or with a flattering premise, even when it's wrong — a reliability and safety risk. System prompt leakage An attack (or accident) where the hidden system prompt — the app's secret instructions — is revealed to the user. Tool poisoning Attacking the *descriptions or schema* of an agent's tools so the model misuses them — a supply-chain attack aimed at the agent's toolbox. Toxicity Harmful, abusive, or hate-laden output from a model — a category of failure safety filters and red teaming target. Transparency Making clear to users and auditors what an AI system does, what it's based on, and where its limits are — trust built on disclosure. Watermarking Embedding a detectable signal in generated text/images so you can tell model output from human output — provenance and abuse control. Zero trust A security posture where nothing inside the system is implicitly trusted — every tool, prompt, and request is verified — a natural fit for LLM agents.