AI glossary: 52 key terms explained, from tokens to benchmarks

AI is any system that performs tasks normally requiring human intelligence — recognizing images, translating languages, making decisions. But there's a critical split in how AI systems work.

Traditional AI follows pre-programmed rules. A spam filter checking for banned keywords is traditional AI: reactive, deterministic, limited to what engineers explicitly coded. Generative AI learns patterns from massive datasets and creates new content — text, images, code, audio — from those patterns. It's proactive rather than reactive, producing outputs its creators never explicitly programmed.

When people say "AI" in 2026, they almost always mean generative AI. The rest of this glossary follows that thread.

Generative AI creates new content by learning patterns from training data, then applying those patterns to produce original outputs. Ask it to write an email, and it generates one word at a time based on statistical patterns it learned during training.

The tools you've likely encountered — ChatGPT, Claude, Gemini, DALL-E — are all generative AI. Each uses a different model architecture, but they share the same fundamental approach: learn patterns, then generate.

Machine learning is the subset of AI where systems learn from data instead of following hard-coded rules. Three flavors exist:

• Supervised learning trains on labeled data. Show the model thousands of photos tagged "cat" and "dog," and it learns to tell them apart.
• Unsupervised learning discovers patterns in unlabeled data. Hand it customer purchase histories with no categories, and it finds natural groupings on its own.
• Reinforcement learning learns through trial and error, receiving rewards for good outcomes and penalties for bad ones — the same approach behind game-playing AI.

All generative AI is built on machine learning. The next term narrows the lens further.

Deep learning is a subset of machine learning that uses neural networks with many layers — at least four, often hundreds or thousands. These layers let the model learn increasingly abstract representations of data: early layers might detect edges in an image, while deeper layers recognize faces.

Deep learning is what made modern generative AI possible.

A neural network stacks simple processing units called neurons in layers. Each neuron computes a weighted sum of its inputs, adds a bias term, then passes the result through a nonlinear activation function. The network learns by adjusting those weights and biases until its outputs match the expected results. For a deeper technical explanation, see IBM's guide to neural networks.

Think of it like a series of filters. Raw data enters the first layer. Each subsequent layer refines the signal, extracting increasingly useful patterns. The final layer produces the output — a classification, a prediction, or a generated token.

The transformer is the neural network architecture behind every major AI model today. Introduced in the 2017 paper Attention is All You Need (Vaswani et al., 2017), it solved a fundamental problem: earlier architectures (RNNs) processed sequences one element at a time, which was slow and made it hard to capture relationships between distant words.

Transformers use a mechanism called self-attention that evaluates all parts of an input simultaneously, determining which elements are most relevant to each other. This parallel processing made transformers faster to train and better at capturing long-range dependencies in text.

Two key subtypes exist. Encoder-only models (like BERT) excel at understanding text — classification, search, sentiment analysis. Decoder-only models (like GPT) excel at generating text — writing, coding, conversation. Most modern chatbots use decoder-only transformers.

An LLM is a transformer-based model pre-trained on vast amounts of text data — sources like Common Crawl (50+ billion web pages) and Wikipedia (60+ million pages across all languages). LLMs contain hundreds of billions to trillions of parameters and can generate, summarize, translate, and reason over text.

The "large" in LLM refers to both the training data and the parameter count.

Parameters are the internal variables — weights, biases, and embeddings — that a model adjusts during training to improve its predictions. Weights control how strongly each input influences the model's decisions. Biases shift decision thresholds.

Scale comparisons put the numbers in context: GPT-3 has 175 billion parameters. GPT-4 is estimated at 1.76 trillion. DeepSeek R1 has 671 billion.

But more parameters don't automatically mean a better model. Architecture, training data quality, and training techniques matter as much or more. DeepSeek R1, with 671 billion parameters, outperforms some models with higher counts on specific benchmarks.

Embeddings are numerical representations that capture meaning. They convert words, sentences, or entire documents into multi-dimensional vectors — arrays of numbers where semantically similar items cluster close together in vector space.

The word "king" and "queen" would sit near each other. So would "Paris" and "France." This spatial relationship lets AI systems understand similarity, analogy, and context without being explicitly taught those connections.

Key algorithms include Word2Vec (captures word associations) and BERT (captures contextual word meanings — "bank" near "river" vs. "bank" near "money"). Embeddings power everything from search to recommendation systems.

The architecture pipeline is now clear: neural networks provide the learning framework, transformers process sequences in parallel, LLMs scale transformers with massive data, parameters define the model's learned knowledge, and embeddings represent meaning as vectors.

A token is the smallest unit of text that language models process. One token equals roughly four characters or 0.75 words. The sentence "How are you doing today?" becomes roughly six tokens.

Every interaction with an AI model — input and output — is measured in tokens. This matters because tokens are what you pay for. API pricing is per million tokens processed.

Tokens aren't limited to text. Images use approximately 258 tokens per tile, video uses 263 tokens per second, and audio uses 32 tokens per second. Understanding tokens is essential for managing costs and knowing why some responses get cut off.

The context window is the model's working memory — the total number of tokens it can consider at once. Think of tokens as the unit; the context window is the capacity.

Current sizes vary dramatically: Claude offers a 200K-token window (with 1 million in beta), Gemini 2.0 Flash handles roughly 1 million tokens, and GPT-5.2 provides up to 400K tokens. A larger context window means the model can process longer documents and maintain coherence across extended conversations.

The trade-off: larger windows increase accuracy and reduce hallucinations, but they require quadratically more computing power. Doubling the window doesn't double the cost — it roughly quadruples it.

The knowledge cutoff is the date after which a model's training data contains no information. Events, publications, and developments after this date are unknown to the model — unless provided through web search grounding, RAG, or explicit context injection.

Current cutoffs (February 2026): GPT-5.2 has a cutoff of August 31, 2025. Claude Opus 4.6 has a cutoff of early 2025. Gemini 3 Pro has a cutoff of September 2025.

Critically, models don't know their own cutoff with precision and may respond about post-cutoff events by hallucinating plausible-sounding information. The mitigation is web search grounding: ChatGPT Search (Bing), Gemini's Google integration, and Copilot's Bing access retrieve real-time information to supplement training memory.

Prompt engineering is the practice of structuring your inputs so the model produces better outputs. The same question, framed differently, can yield dramatically different results.

Key techniques include:

• Zero-shot prompting: Ask directly with no examples. "Translate this to French."
• Few-shot prompting: Provide examples of the pattern you want. Show three translations, then ask for a fourth.
• Chain-of-thought prompting: Ask the model to reason step by step, which improves accuracy on complex problems.
• Role prompting: Assign a persona. "You are a senior data analyst. Review this dataset."
• Prompt chaining: Link multiple prompts for complex tasks — first summarize, then analyze, then recommend.

Mastering these techniques is the fastest way to get more value from any AI tool. See our AI prompts collection for ready-to-use examples.

Chain-of-thought (CoT) prompting instructs the model to work through a problem step by step before stating its final answer. Instead of jumping to a conclusion, the model shows its reasoning.

The simplest implementation: append "Think step by step" or "Show your reasoning" to the prompt. Few-shot CoT goes further: show two or three worked examples of step-by-step reasoning, then present the target problem.

Why it works mechanically: autoregressive models generate each token conditioned on prior tokens. When forced to generate intermediate reasoning steps, the model's attention over those visible steps improves the quality of the final answer — the written reasoning acts as a scaffold that the completion must be consistent with.

CoT adds tokens (and therefore cost and latency) to every request. Extended thinking modes in Claude, ChatGPT, and Gemini automate CoT internally, so manual CoT prompting matters most when using base models or APIs without built-in thinking modes.

A system prompt is a set of instructions given to an AI model before any user interaction begins. It defines the model's persona, tone, task scope, constraints, and persistent context — without the user needing to repeat these in every message.

Examples of effective system prompt content:

• Persona: "You are a senior financial analyst. Always cite data sources."
• Constraints: "Only discuss topics related to our product. Redirect off-topic questions politely."
• Format rules: "Always respond in bullet points. Use British English."
• Context: "The user's company is Acme Corp. Their primary market is healthcare IT."

System prompts are the primary mechanism for customizing AI behavior in production applications. API users set them programmatically per session. Consumer products like ChatGPT and Claude expose them through Custom Instructions settings.

Temperature controls the randomness of a model's output during inference. It scales the probability distribution over next-token predictions via the softmax function.

Low temperature (0.0–0.3) produces focused, deterministic outputs — ideal for factual tasks, code generation, and data extraction. The model picks the highest-probability token almost every time.

High temperature (above 1.0) flattens the probability curve, giving lower-probability tokens a better chance of being selected. This increases variety but can also produce nonsensical output.

A common misconception: temperature doesn't control "creativity." The model doesn't become more intelligent at higher settings. It becomes more random. The quality ceiling stays the same; the floor drops.

Structured outputs is an AI capability that constrains the model to return data in a specified format — typically JSON, XML, or a custom schema — rather than free-form text. You define the expected structure; the model guarantees it produces data that conforms to it.

Example: instead of asking "What are the key dates in this contract?" (free-text response), you provide a JSON schema with fields {party_name, effective_date, termination_date, notice_period} — and the model fills each field reliably.

Structured outputs differ from asking the model to "please format as JSON." That approach produces valid JSON most of the time. True structured outputs use constrained decoding to guarantee format compliance — the model physically cannot produce tokens that would break the schema.

Supported by: GPT-5.2 API (strict mode), Gemini API (JSON mode with schema), Claude API (tool use as structured output mechanism).

Inference is what happens every time you send a prompt — the model generating output from your input. If training is school, inference is the job.

Three phases occur during inference: prefill (processing all input tokens simultaneously), decode (generating output tokens one at a time), and output conversion (turning tokens into readable text).

Inference must be fast because it happens in real time. And every token generated costs money. Training happens once and takes days or weeks. Inference happens millions of times a day and must complete in seconds.

Latency in AI measures the time between sending a request and receiving a response. Two figures matter in practice:

Time to first token (TTFT): How long until the model begins streaming output. Critical for interactive interfaces — 500ms TTFT feels sluggish; under 200ms feels instant. ChatGPT's Advanced Voice Mode targets a 232ms average TTFT.

End-to-end latency: Total time to complete the full response. Scales with output length because autoregressive generation produces tokens sequentially — a 1,000-token response always takes longer than a 100-token one.

Three levers drive latency: model size (larger models are slower on equivalent hardware), hardware (specialized inference chips reduce TTFT significantly), and output length (unavoidably linear). Extended thinking modes add 2–30 seconds depending on reasoning depth.

Training data is the information a model learns from. It can be labeled (each data point tagged with the correct answer, used in supervised learning) or unlabeled (raw data the model finds patterns in on its own).

Quality matters more than quantity. A model trained on carefully curated, diverse, well-structured data outperforms one trained on a larger but noisy dataset. Preparation involves collection, cleaning, transformation, feature engineering, and splitting into training, validation, and test sets.

Training is the process of teaching the model by exposing it to data and adjusting its parameters. The cycle repeats millions of times: input data flows through the network (forward pass), the model's predictions are compared against expected results (error calculation), errors propagate backward through the layers (backpropagation), and weights update via gradient descent.

This is compute-intensive work. Training Llama 3.1 (405 billion parameters) required roughly 38 yottaflops — that's 3.8 x 10^25 math operations. Training runs take days or weeks on clusters of specialized hardware.

The key distinction: training happens once (or rarely). Inference happens every time someone sends a prompt. The next two terms cover ways to adapt a trained model without starting from scratch.

Fine-tuning adapts a pre-trained model to a specific task or domain. Instead of training from zero, you take an existing model and refine it with specialized data.

Three main approaches:

• Full fine-tuning updates all parameters. Effective but expensive.
• Parameter-efficient fine-tuning (PEFT) updates only a small subset. LoRA (Low-Rank Adaptation) is the most popular technique — it injects small trainable matrices into transformer layers, reducing the number of parameters that need updating by orders of magnitude. LoRA can run on consumer GPUs with 24 GB of memory.
• RLHF (Reinforcement Learning from Human Feedback) trains a reward model from human rankings, then optimizes the LLM to maximize those reward scores. This is how ChatGPT learned to be helpful rather than harmful.

The myth that fine-tuning requires massive compute is outdated. LoRA changed the game.

RAG supplements a model's knowledge at inference time with external data. Instead of relying solely on what the model learned during training, RAG retrieves relevant information from an external knowledge base and injects it into the prompt.

The process follows four steps: embed the external data as vectors, retrieve the most relevant chunks based on the user's query, augment the prompt with retrieved context, and generate a response that incorporates that context.

RAG is cost-effective (no retraining needed), keeps information current, and enables source attribution. But it doesn't replace training — it supplements it. A poorly trained model won't produce good outputs even with perfect retrieval.

The progression: fine-tuning changes the model itself. RAG changes what the model sees at inference time.

A hallucination occurs when a model generates plausible-sounding but factually incorrect content. The model isn't lying — it's predicting the most statistically likely next token without any mechanism for fact-checking.

Causes include overfitting to training data, biased datasets, and the fundamental nature of statistical prediction. Leading models report hallucination rates as low as 0.7%–0.9%, while many widely used models fall between 2% and 5%.

Two factors from earlier sections connect directly: higher temperature increases randomness and can raise hallucination rates. Larger context windows help reduce hallucinations by giving the model more relevant information to work with. Understanding both concepts helps you manage hallucination risk in practice.

AI bias refers to systematic errors that produce unfair outcomes. Three primary sources feed it:

• Biased training data — if the dataset underrepresents certain groups, the model inherits those gaps.
• Algorithmic bias — design choices in the model architecture that reinforce existing patterns.
• Human interpretation bias — people applying model outputs without questioning assumptions.

Mitigation requires diverse, representative training data, regular fairness audits, and human oversight at decision points. No model is bias-free, but awareness of these sources is the first step toward responsible use.

Guardrails are the technical and procedural controls that keep AI systems within safe boundaries. They work in three layers:

• Input filtering screens what the model receives — blocking prompt injection attempts, PII exposure, and harmful requests.
• Processing constraints limit model behavior during generation — enforcing topic boundaries and compliance rules.
• Output enforcement validates responses before they reach the user — checking for harmful content, factual consistency, and policy alignment.

Guardrails don't make models infallible. They make the risks manageable. Every production AI deployment needs them.

Natural language processing is the broader field that makes human-computer language interaction possible. It combines computational linguistics, statistical modeling, and deep learning into a pipeline: text preprocessing (cleaning and structuring raw text), feature extraction (identifying meaningful patterns), text analysis (applying models to understand meaning), and model training (improving accuracy with feedback). Google's machine learning glossary provides additional NLP definitions worth bookmarking.

Key tasks within NLP include named entity recognition (identifying people, places, and organizations in text), sentiment analysis (determining emotional tone), and part-of-speech tagging (classifying words by grammatical role). LLMs operate under the NLP umbrella — they're the most powerful NLP tools ever built, but NLP as a discipline predates them by decades.

Multimodal AI processes and generates multiple types of data simultaneously — text, images, audio, video, and increasingly 3D spatial data. Unlike single-modality models that handle only text, multimodal systems interpret combinations of inputs.

Current examples: GPT-4o processes text, images, and audio. Claude handles text and images. Gemini works across text, images, audio, and video. The trajectory is clear — future AI systems will be natively multimodal, processing information the way humans do: through multiple senses at once.

MMLU tests general knowledge across 57 subjects — from STEM and law to nutrition and religion — using 15,908 multiple-choice questions. Released in September 2020 by Dan Hendrycks et al., it quickly became the standard measure of how well a model handles diverse factual knowledge. The original MMLU benchmark paper (Hendrycks et al., 2020) details the methodology.

By mid-2024, top models had nearly saturated the original benchmark, scoring so high that differences between them became statistically insignificant. This saturation sparked several spin-offs: MMLU-Pro (harder questions), MMMLU (multilingual version), and MMLU-Redux (corrected errors in the original).

A high MMLU score means a model performs well on factual recall across disciplines. It doesn't measure reasoning depth, creative ability, or real-world task completion. Treat it as one data point, not a verdict.

HumanEval measures coding ability through 164 hand-crafted Python programming challenges, each with a function signature, docstring, and unit tests (averaging 7.7 tests per problem). OpenAI developed and released it in 2021 alongside the Codex model. The test suite is available in OpenAI's HumanEval repository.

It uses the pass@k metric: the probability that at least one of k generated code samples passes all unit tests. This approach accounts for the variability in AI-generated code — the model might get it right on the third try even if the first two fail.

HumanEval remains the most-cited coding benchmark, though successor benchmarks like BigCodeBench are emerging to test more complex programming scenarios.

For a deeper look at how benchmark scores compare across models, see the AI tools comparison page.

SWE-bench measures AI coding ability using 2,294 real GitHub issues and pull requests sourced from popular open-source Python projects. Models must read the issue, understand the codebase, write a patch, and pass the project's existing test suite — without human assistance at any step.

SWE-bench Verified (500 human-validated problems) is the standard version cited in model releases. The metric is resolve rate: the percentage of issues the model correctly patches on the first attempt.

As of February 2026: Claude Opus 4.6 leads at 80.8%, GPT-5.2 at 80.0%, Gemini 3 Pro at 74.2%. Unlike HumanEval's 164 hand-crafted Python problems, SWE-bench tests production-grade software engineering — the gap between a 75% and 80% score translates to real differences in autonomous coding capability.

ARC-AGI-2 (Abstraction and Reasoning Corpus) tests AI on novel visual grid puzzles that humans typically solve in minutes but that require genuine abstract reasoning — not pattern recall from training data. Each puzzle shows a series of colored grid transformations and asks the model to identify the underlying rule.

The benchmark is deliberately resistant to memorization: problems are generated from new rules each evaluation, so a model can't improve by studying past examples. Results are verified by the ARC Prize Foundation.

As of February 2026: Gemini's Deep Think mode leads at 84.6%, Claude Opus 4.6 scores 68.8%, GPT-5.2 Pro scores 54.2%. The gap between 54% and 84% represents fundamentally different abstract reasoning capability.

Terminal-Bench 2.0 measures AI ability on command-line and DevOps tasks: file manipulation, shell scripting, network diagnostics, process management, and system configuration. Problems run in live Linux environments and are evaluated on whether the AI's commands produce the correct system state — not just the correct output text.

This execution-based evaluation makes it harder than benchmarks that only check generated text. The model must run commands, observe results, and self-correct autonomously.

As of February 2026: Claude leads at 65.4%, GPT-5.2 at 56.2%. The 9-point gap reflects Claude's strength on multi-step agentic tasks in constrained environments.

GDPval-AA (General Document Processing and Valuation — Advanced Analysis) measures AI performance on business document tasks: financial statement analysis, contract review, earnings call interpretation, and strategic document synthesis. Scoring uses an Elo-based head-to-head comparison system — human evaluators compare two models' outputs on the same document and indicate which is stronger.

As of February 2026: Claude Opus 4.6 scores 1606 Elo versus Gemini 3 Pro's 1195 — a 411-point gap that represents a substantial practical difference in business analysis quality.

Elo is a pairwise ranking system originally developed for chess. In AI evaluation, platforms like LMArena present outputs from two anonymous models on the same prompt to human raters, who choose which response they prefer. The Elo algorithm updates both models' scores based on the outcome — an upset (weaker model beats stronger) moves scores more than an expected result.

As of February 2026: Gemini 3 Pro leads LMArena at 1501, Grok 4.1 leads thinking mode at 1483, GPT-5.2 and Claude Opus 4.6 cluster near 1440–1460.

Elo ratings capture overall user preference on open-ended tasks. They correlate imperfectly with task-specific benchmarks — a model can lead on Elo but trail on SWE-bench or ARC-AGI-2.

Autoregressive generation is how LLMs produce text: predict one token at a time, using all previously generated tokens as context for the next prediction. Each output token depends on all prior tokens — hence "autoregressive."

The decode loop: (input prompt + all tokens generated so far) → probability distribution over vocabulary → sample one token → append to context → repeat until done.

This constraint explains two core LLM behaviors. First, generation is sequential — you can't produce token 100 without first producing tokens 1–99, which is why longer responses take longer. Second, each token is statistically likely given prior context — the model has no end-to-end check whether the complete sentence will be factually correct, which is a root cause of hallucinations.

OpenAI applied autoregressive generation to image pixels rather than text tokens for GPT Image — contrasting with diffusion models that start from noise and iteratively refine it.

A diffusion model generates images (and increasingly audio and video) by reversing a noise-adding process. During training, the model learns to predict how to "de-noise" a partially noisy version of a real image, one step at a time. During generation, it starts from pure random noise and applies the learned de-noising process repeatedly until a coherent image emerges.

Key examples: DALL-E 3 (API deprecated November 2025), Midjourney V6 and V7, Stable Diffusion, Adobe Firefly.

The core contrast with autoregressive generation: diffusion models refine all parts of the image simultaneously across multiple steps, while autoregressive image models generate pixels sequentially. Diffusion models excel at coherent full-image compositions; they historically struggle with text rendering and precise instruction-following — two areas where OpenAI cited advantages when switching ChatGPT's image generation to an autoregressive architecture (GPT Image) in March 2025.

Agentic AI refers to systems that autonomously execute multi-step tasks — planning, taking action, observing results, and correcting course — without human approval at each individual step. The contrast is with single-query chatbots that answer one question and wait for the next.

A coding agent, for example, receives a feature request, reads the codebase, writes code, runs tests, interprets failures, and revises until tests pass. Current examples: Claude Code, ChatGPT Codex, Gemini's Jules, Grok's DeepSearch.

Four properties distinguish agents from chatbots: persistence (maintaining state across multiple steps), tool use (reading files, executing code, browsing the web), self-correction (adjusting based on intermediate results), and goal-directedness (pursuing an outcome rather than answering a single prompt).

The glossary entry "AI agents are fully autonomous" captures the key limitation: current agents require well-defined scope, guardrails, and human oversight for production use. They're capable interns, not independent colleagues.

Extended thinking is a reasoning mode where the model works through intermediate steps internally before producing its final answer. Instead of predicting the most statistically likely next token immediately, the model generates a chain of reasoning — checking assumptions, exploring alternatives, catching errors — then produces an output informed by that reasoning trace.

Implementations differ across products: Claude Opus 4.6 uses adaptive thinking (four effort levels the model self-selects based on problem complexity). Gemini Ultra's Deep Think mode applies extended reasoning with a 192K-token internal budget. ChatGPT's Thinking mode offers Standard, Light, and Extended variants.

Extended thinking increases latency (seconds to tens of seconds) and token consumption. For simple lookups, the overhead isn't worth it. For complex reasoning, math, planning, and coding tasks, the accuracy improvement is significant.

Deep Research is an agentic workflow where an AI model autonomously conducts multi-source research and synthesizes a structured report — without the user manually browsing and reading each source.

The workflow: receive a complex research question → decompose into sub-queries → search multiple sources → read and evaluate retrieved pages → synthesize findings → produce a cited report. Full execution takes 2–15 minutes depending on scope.

Current implementations: ChatGPT Deep Research (powered by o3 reasoning; Free 5/month, Plus 25/month, Pro 250/month), Gemini Deep Research (AI Pro and Ultra tiers), Grok's DeepSearch (distinctive in also searching X/Twitter posts alongside web sources).

The quality difference from simple web search grounding: Deep Research reads and reasons over dozens of sources in sequence, not just the top few results. Output is a synthesized report with structure and citations — not a list of retrieved snippets.

Web search grounding supplements AI responses with live search results, reducing reliance on potentially stale training data. When activated, the model searches the web, retrieves relevant pages, and incorporates their content into its response — typically with source citations.

Current implementations: ChatGPT Search (Bing-powered, available on all tiers including Free since February 2025), Gemini Search (Google-powered, default in Gemini app), Copilot (Bing-powered, always on), Perplexity (search-first AI).

The distinction from RAG: web search grounding retrieves from the live public internet. RAG retrieves from your own private documents. Both reduce hallucinations by giving the model specific text to work from rather than relying on training memory. Neither eliminates hallucination — the model still synthesizes retrieved content and can misinterpret sources.

Source grounding restricts an AI model to responding only from specific documents you provide, rather than its training data or the web. Every response includes citations pointing back to exact passages in those documents.

NotebookLM is the purest example: upload PDFs, research papers, or meeting notes, and every answer the AI gives links to the source paragraph that supports it. If the answer isn't in your sources, the model says so rather than hallucinating from training data.

Source grounding makes hallucination structurally harder: the model can't fabricate information it wasn't given. Errors still occur — the model can misinterpret source text — but they're detectable because every claim has a traceable citation. This is the key advantage over web search grounding, which retrieves broadly rather than precisely.

MCP is an open standard that defines how AI models connect to external tools and data sources. Anthropic describes it as "USB-C for AI": a single connector specification that works across compatible systems rather than requiring a different integration for every model-tool combination.

Published by Anthropic in 2024, MCP lets developers build one integration that works with any MCP-compatible AI system. Current connectors include Slack, GitHub, Figma, Asana, Notion, databases, and file systems. Claude supports 50+ connectors; Copilot Studio has generally available MCP support.

Before MCP, connecting an AI to external tools required custom integration work per AI provider. MCP standardizes the interface so one integration serves all compatible models — reducing development overhead and preventing vendor lock-in.

Data residency refers to requirements — legal, contractual, or organizational — specifying which country or region AI data (prompts, outputs, user data) must be stored and processed in.

Relevant regulations: GDPR requires data protection for EU residents but doesn't automatically mandate geographic storage. Some EU member states, plus sector-specific rules in healthcare and finance, impose stricter geographic constraints. Japan's APPI and similar national laws add regional layers.

Current AI provider options: ChatGPT Enterprise offers EU Data Boundary, US, and Japan. Microsoft Copilot supports data residency across EU, UK, US, Canada, Japan, South Korea, Singapore, India, Australia, and UAE. Google Workspace AI supports EU, US, and multi-region configurations.

For most individuals and SMBs, data residency is not a concern. For regulated industries (healthcare, finance, government) and EU-based enterprises, it's often a hard procurement requirement.

Copyright indemnity (also called IP indemnity or Copyright Shield) is a legal guarantee from an AI provider to defend you and cover damages if a third party sues you for copyright infringement based on AI-generated content.

Who offers it: OpenAI provides Copyright Shield for API and Enterprise customers. Microsoft offers the Copilot Copyright Commitment for commercial Copilot users. Anthropic covers API commercial users under its standard terms.

Who doesn't: Midjourney explicitly does not offer IP indemnity. Most image generation services provide none.

Key exclusions across all providers: deliberate attempts to reproduce specific protected works, ignored infringement warnings, and use outside authorized terms. For individual users, copyright indemnity rarely matters practically. For enterprises publishing or monetizing AI-generated content at scale, it's a legitimate vendor selection criterion.

Parameters matter, but architecture, training data quality, and training technique matter more. DeepSeek R1 (671 billion parameters) outperforms some models with higher counts on specific benchmarks.

LLMs predict statistically likely next tokens based on learned patterns. They don't possess semantic understanding. This is why hallucinations happen — the model produces plausible text without verifying facts.

Temperature controls randomness, not intelligence. High temperature doesn't make the model more creative — it makes it more random. The quality ceiling stays fixed; the floor drops.

LoRA and other parameter-efficient techniques can fine-tune models on consumer GPUs with 24 GB of memory. The barrier to entry has collapsed.

RAG supplements a model's knowledge at inference time. It can't fix a fundamentally weak model — the base still needs proper training.

The context window is temporary working memory for a single conversation. When the session ends or the window fills up, the model retains nothing. It's a whiteboard, not a hard drive.

Current AI agents operate with a degree of autonomy, but they require human oversight, guardrails, and well-defined boundaries. They're more like capable interns than independent colleagues.