AI Glossary

138 terms, one clear definition each - foundations to shipping.

138 terms

A

AGIFoundations: 'Artificial general intelligence' - hypothetical AI matching humans across most cognitive work. A marketing magnet and a research aspiration, not a product today.
AI AgentAgents: An LLM wrapped in a loop: think → act via tools → observe results → repeat until the goal is met.
AlignmentSafety & Ethics: Making models pursue intended goals and refuse harmful ones - the field RLHF and Constitutional AI belong to.
Artificial Intelligence (AI)Foundations: Umbrella term for software that performs tasks we associate with human intelligence - perception, language, planning, prediction.
AttentionModels: The mechanism letting a model weigh every earlier token when producing the next one - how long-range dependencies get handled.
Autonomy LevelAgents: How much the agent decides without approval. Ship levels: suggest → act-with-confirm → fully autonomous.

B

BackpropagationTraining: The algorithm computing how each weight contributed to the error, letting training update them sensibly.
Base Model vs Instruct ModelModels: A base model completes text; an instruct/chat model is tuned to follow instructions. Building on raw base models needs few-shot tricks.
Batch SizeTraining: How many examples are processed per update step; interacts with learning rate and memory limits.
BenchmarkFoundations: A standardized test set for comparing models. Scores leak into training data over time, so treat them as one signal, not proof.
Bias (parameter)Foundations: An extra learned constant added to a neuron's output before activation, letting it fire even with zero input.
Bias (societal)Safety & Ethics: Systematic skew in outputs reflecting patterns in training data - accents, genders, regions. Test with diverse probes.
BYOKShipping: 'Bring Your Own Key' - users supply their own API keys so your costs stay near zero while they pay their provider directly.

C

Canary ReleaseShipping: Rolling a new prompt or model to a small traffic slice first, comparing evals before full rollout.
Catastrophic ForgettingTraining: When fine-tuning erases skills the model previously had; mitigate with mixed data or adapters.
Chain-of-Thought (CoT)Prompting: Asking the model to reason step-by-step before answering; reliably improves math, logic and multi-step tasks.
ChunkingRAG & Memory: Splitting documents into retrievable passages. Chunk size and overlap quietly decide whether RAG works at all.
CitationRAG & Memory: Pointers from generated claims back to source passages; build them into retrieval UX from day one.
ClaudeModels: Anthropic's family of LLMs, known for long-context reasoning, careful instruction-following and strong writing.
Computer UseAgents: Agents operating real UIs - clicking, typing, scrolling screenshots - for software without APIs.
Consent & ProvenanceSafety & Ethics: Knowing you had the right to train on or feed data to a model, and being able to say where outputs came from.
Constitutional AITraining: Anthropic's approach: critique and revise model outputs against a written set of principles rather than raw human labels.
Content ModerationSafety & Ethics: Classifying user and model content against policy; use provider moderation endpoints plus your own rules.
Context DistillationModels: Training technique where a student model internalizes knowledge a teacher expresses in prompts, shrinking runtime context.
Context RotPrompting: Quality drift in very long conversations; fix with summaries or fresh sessions rather than hoping.
Context WindowFoundations: How much text a model can consider at once, measured in tokens. Everything - system prompt, documents, history - shares this budget.
Cosine SimilarityFoundations: A 0-to-1 style score of how aligned two vectors are; the standard way to rank embedding matches.
Cost per TokenShipping: What input/output tokens cost. Cache aggressively, compress prompts, and route easy jobs to cheaper models.
Curriculum LearningTraining: Ordering training examples easy → hard to improve learning stability.

D

Data AugmentationTraining: Synthesizing extra training variety (paraphrases, crops, noise) to reduce overfitting.
Data RetentionSafety & Ethics: How long providers keep your prompts. Zero-retention options exist for sensitive workloads - ask before you ship.
Deep LearningFoundations: ML using many-layered neural networks; the technique behind modern image, speech and language models.
Diffusion ModelModels: Image/video generator that learns by reversing gradual noising; the tech inside Stable Diffusion, Midjourney-style tools and video generators.
DistillationTraining: Training a small model to imitate a large one's outputs, cutting cost and latency for production.

E

EmbeddingFoundations: A list of numbers representing meaning so that similar texts land close together; the backbone of search and recommendations.
Embedding ModelModels: A model whose whole job is turning text into vectors for search, clustering and dedupe.
Emergent AbilityFoundations: A capability that appears only at scale and was absent in smaller versions of similar models.
EpochTraining: One full pass over the training dataset. Fine-tuning often uses 1-3 epochs; more invites memorization.
EU AI ActSafety & Ethics: EU regulation classifying AI systems by risk tier with obligations for transparency and documentation; affects EU-facing products.
EvalShipping: Automated test of model output quality - golden sets, rubric scoring, LLM-as-judge. Your regression suite for prompts.
ExplainabilitySafety & Ethics: Understanding why a model produced an output. Post-hoc explanations help debugging but aren't proof.

F

Fallback ModelShipping: Backup model used when the primary errors or rate-limits, keeping the product alive through provider incidents.
Few-shotPrompting: Including a handful of worked examples in the prompt so the model imitates the pattern.
Fine-tuningTraining: Continuing to train a pre-trained model on your narrower dataset to shift its style, format or domain skill.
Foundation ModelFoundations: A large general-purpose model trained on broad data that gets adapted to many downstream tasks.

G

GANModels: Generative Adversarial Network - a generator and a discriminator trained against each other; dominated image generation before diffusion.
GeminiModels: Google DeepMind's multimodal model family spanning text, image, audio and video inputs.
Golden DatasetShipping: Hand-checked input/output pairs representing correct behavior; the reference every prompt or model change is tested against.
GPTModels: 'Generative Pre-trained Transformer', OpenAI's LLM family name; also used generically for the architecture style.
GroundingRAG & Memory: Tying answers to cited sources so users can verify claims; the main defense against hallucination in products.
GuardrailAgents: Code-level checks around a model (input filters, output validators, spend caps) that hold regardless of what the model says.

H

HallucinationFoundations: When a model states something false with full confidence, because it generates plausible text rather than verified facts.
Human-in-the-LoopAgents: Design where a person approves consequential actions; still best practice for anything irreversible.
Hybrid SearchRAG & Memory: Combining keyword (BM25) and vector search; catches exact terms embeddings blur away.

I

IdempotencyAgents: Designing actions so accidental double-execution is safe - vital once agents can trigger real side effects.
InferenceFoundations: Running a trained model to get an output. Training happens once; inference happens on every request and drives your API bill.
Instruction TuningTraining: Fine-tuning on prompt→response pairs so the model follows instructions instead of merely continuing text.

J

JailbreakPrompting: Deliberate prompting to bypass a model's safety rules; why guardrails must be layered, never single-prompt.

K

Knowledge BaseRAG & Memory: Your curated corpus (docs, FAQs, tickets) that retrieval draws from; freshness matters more than size.

L

Label NoiseTraining: Errors in training labels; models happily learn mistakes, so dataset hygiene beats fancy tricks.
LatencyShipping: Time to first token plus stream speed. Perceived speed depends on streaming UX as much as raw model speed.
Latent SpaceFoundations: The internal coordinate space where a model represents concepts. Nearby points mean similar meanings.
Learning RateTraining: Step size for weight updates. Too high diverges, too low crawls; schedules decay it during training.
LlamaModels: Meta's open-weight LLM family; the base for many self-hosted and fine-tuned deployments.
LLMModels: Large Language Model - a transformer trained to predict the next token over huge text corpora. The engine behind chatbots and copilots.
LLM-as-JudgeShipping: Using a strong model to score outputs against criteria; scalable review that still needs spot-checking by humans.
Long-term MemoryRAG & Memory: Persistent facts stored outside the window (profile notes, preferences) and re-injected when relevant.
LoRATraining: Low-Rank Adaptation - fine-tunes small adapter matrices instead of all weights, making tuning possible on one GPU.
Loss FunctionTraining: The number measuring how wrong predictions are; training is gradient descent pushing this down.

M

Machine Learning (ML)Foundations: A subset of AI where programs learn patterns from data instead of being hand-coded with explicit rules.
Max TokensPrompting: Hard cap on response length. Set it deliberately - it bounds both cost and rambling.
MCP (Model Context Protocol)Agents: Open standard for connecting AI apps to external tools and data sources through one protocol instead of bespoke integrations.
Meta-PromptingPrompting: Using a model to write or improve prompts for another model - the 'Improve Prompt' pattern.
Metadata FilteringRAG & Memory: Restricting vector search by attributes (tenant, date, doc type) - mandatory for multi-user systems.
MistralModels: European lab producing efficient open-weight models famous for strong quality-per-parameter.
Mixture of Experts (MoE)Models: Architecture where only some 'expert' sub-networks activate per token, giving big-model capacity at lower compute.
Model CardSafety & Ethics: Standardized documentation of a model's training data, limits and intended use; read it before trusting benchmarks.
Model RoutingShipping: Sending simple requests to small models and hard ones to frontier models automatically - cuts bills without visible quality loss.
Multi-Agent SystemAgents: Several specialized agents collaborating (researcher, writer, critic). Powerful but harder to debug than one good loop.
MultimodalFoundations: A model that handles more than one data type - text plus images, audio or video - in the same system.

N

Negative PromptPrompting: In image generation, things to exclude ('no text, no watermark') alongside the positive description.
Neural NetworkFoundations: A stack of simple mathematical units ('neurons') whose connection weights are tuned during training to map inputs to outputs.

O

ObservabilityShipping: Logging prompts, completions, latencies and costs per request so failures are diagnosable after the fact.
On-device AIShipping: Running quantized models locally for privacy, offline use and zero marginal cost - great for small, well-scoped tasks.
Open WeightsModels: Model files you can download and run yourself. License still governs commercial use - check it before shipping.
OrchestrationAgents: The framework layer routing tasks between models, tools and humans - LangChain, custom queues, workflow engines.
Output FormattingPrompting: Explicitly pinning structure - markdown tables, numbered sections, JSON schemas - so results parse downstream.
OverfittingTraining: Memorizing the training set so well that new inputs perform worse; classic symptom: perfect eval, bad demo.

P

ParameterFoundations: A learned number inside a model. '7B model' means seven billion parameters; more is not automatically better.
PIISafety & Ethics: Personally Identifiable Information. Redact before sending third-party APIs and know where it is stored.
PlanningAgents: Having the agent decompose a goal into steps first; dramatically improves long multi-tool tasks.
Pre-trainingTraining: The expensive first phase: learning language by predicting next tokens across trillions of words.
PromptPrompting: Everything you send to the model - instructions, context, examples. Quality in, quality out.
Prompt ChainingPrompting: Splitting a complex job into sequential prompts, each validating one step - more reliable than one mega-prompt.
Prompt InjectionPrompting: Attack where untrusted text (a web page, an email) contains hidden instructions that hijack the model. Treat all external text as hostile.
Prompt TemplatePrompting: A reusable prompt skeleton with {{placeholders}} your app fills at runtime.
Prompt VersioningShipping: Treating prompts as versioned artifacts with tests and changelogs, not strings scattered through code.

Q

QLoRATraining: LoRA over a quantized frozen base model; fine-tune big models on modest hardware.
QuantizationModels: Storing model numbers in fewer bits (8-bit, 4-bit) so they fit smaller hardware, trading some accuracy.

R

RAGRAG & Memory: Retrieval-Augmented Generation: fetch relevant documents at question time and let the model answer grounded in them.
Rate LimitShipping: Provider cap on requests per minute/day. Design for 429s with queuing and backoff before launch day finds out for you.
Re-rankingRAG & Memory: A second-pass model reorders retrieved chunks by true relevance, sharpening precision before generation.
ReActAgents: Reason + Act pattern: the model interleaves reasoning traces with tool calls instead of answering blindly.
Red TeamingSafety & Ethics: Adversarially attacking your own AI feature before strangers do; document what broke and what now blocks it.
ReflectionAgents: Agent critiques its own draft and retries - a cheap quality boost when a verifier is unavailable.
Retry PolicyAgents: Your plan for failed calls: exponential backoff, fallback models, and a maximum attempt count.
RLAIFTraining: Like RLHF but the preferences come from AI judges instead of paid human raters.
RLHFTraining: Reinforcement Learning from Human Feedback - aligns model behavior using human preference rankings between candidate answers.
Role PromptingPrompting: Assigning a persona ('You are a senior contract lawyer…') to steer vocabulary, depth and priorities.

S

Scaling LawFoundations: The observed pattern that model quality improves predictably as you grow parameters, data and compute together.
SeedPrompting: Randomness anchor that makes generations reproducible; fix it while iterating on a prompt.
Self-AttentionModels: Attention where a sequence relates its own positions to each other, capturing which words matter to which.
Semantic CacheShipping: Reusing earlier answers for semantically identical questions; big savings, mind staleness and personalization.
Semantic SearchRAG & Memory: Search by meaning rather than keywords - 'refund policy' matching 'money-back guarantee'.
Short-term MemoryRAG & Memory: Recent turns kept in the context window; simplest form of conversational continuity.
Small Language Model (SLM)Models: Compact LLMs (roughly under 10B parameters) that run cheaply or on-device with surprisingly usable quality.
Stop SequencePrompting: A string that ends generation early, useful when the model would otherwise continue past your needed output.
Streaming (SSE)Shipping: Sending tokens as they generate so users watch text appear; the single biggest perceived-quality upgrade.
Structured Output / JSON ModePrompting: API feature forcing responses to valid JSON against your schema; essential when code consumes the reply.
Summarization BufferRAG & Memory: Compressing older conversation into a running summary so long chats keep working within token budgets.
SycophancySafety & Ethics: Models agreeing with users to please them - a known failure mode that corrupts feedback loops and reviews.
System PromptPrompting: Hidden instructions defining role, rules and format for the whole conversation; set before user messages.

T

Task DecompositionAgents: Breaking a job into subtasks an LLM can complete reliably; the difference between demos and dependable products.
TemperaturePrompting: Sampling dial: low (0-0.3) for deterministic factual tasks, high (0.7-1) for brainstorming and creative variety.
TokenFoundations: The chunk of text a language model reads and writes - roughly ¾ of a word in English. Pricing and context limits are quoted in tokens.
TokenizerFoundations: The component that splits text into tokens using a fixed vocabulary; explains why models sometimes miscount letters or characters.
Tool Use / Function CallingAgents: Letting the model call your functions (search, calendar, DB query) by emitting structured arguments your code executes.
Top-p (nucleus sampling)Prompting: Alternative randomness control: sample only from the smallest set of tokens covering probability mass p.
TransformerModels: The neural architecture behind nearly all modern LLMs, built around attention instead of recurrence.

U

UnderfittingTraining: The opposite - model too weak or trained too little to capture the pattern at all.

V

VectorFoundations: The array of numbers behind an embedding. 'Vector database' just means a store that can find nearest vectors fast.
Vector DatabaseRAG & Memory: Storage optimized for similarity search over embeddings - pgvector, Pinecone, Qdrant, Chroma and friends.
Vendor Lock-inShipping: Dependency on one provider's quirks and pricing. Mitigate behind an interface and keep a second provider warm.
Vision-Language Model (VLM)Models: A model that reads images and text together, enabling screenshot understanding, OCR-ish extraction and visual QA.

W

WatermarkingSafety & Ethics: Embedding detectable signals in AI-generated media to label provenance; partial but improving.
WeightFoundations: A parameter that scales how strongly one signal influences another; training adjusts millions to billions of them.
WhisperModels: Open-source speech-to-text model from OpenAI, widely used for transcription pipelines.

Z

Zero-shotPrompting: Asking without any examples - relies purely on instructions.