AI Tools Glossary

AI systems designed to autonomously pursue goals through multi-step planning, tool use, and iterative action — operating in loops without requiring continuous human instruction. Agentic systems can browse the web, execute code, call APIs, manage files, and coordinate with other agents to complete complex, open-ended tasks. Distinguished from standard chatbots by their ability to act in the world, not just respond.

A software program that perceives its environment, makes decisions, and takes actions to achieve a defined goal. Modern AI agents are typically built on top of LLMs and augmented with tools (web search, code execution, database access). They operate in a Perceive → Reason → Act → Observe loop, adapting behavior based on feedback from previous actions.

The research discipline focused on ensuring AI systems reliably pursue the goals and values intended by their designers and humanity at large. Alignment problems arise because optimizing narrowly for a measurable objective can lead to unexpected, harmful behaviors. Key approaches include RLHF, Constitutional AI, and debate-based training. Misalignment at scale is considered an existential risk by many researchers.

Systematic and unfair discrimination in AI model outputs, typically inherited from imbalanced or historically biased training data, or amplified by the objective function. Bias can manifest as racial, gender, socioeconomic, or cultural disparities in model predictions and generations. Mitigation strategies include dataset curation, adversarial debiasing, and fairness-aware training objectives.

The interdisciplinary field dedicated to ensuring AI systems are safe, controllable, and beneficial throughout their development and deployment lifecycle. Safety work spans near-term concerns (preventing jailbreaks, reducing hallucinations) and long-term concerns (avoiding catastrophic misuse or loss of human control over superintelligent systems). Key organizations include Anthropic, DeepMind Safety, and ARC Evals.

The broad science and engineering of creating computational systems capable of performing tasks that typically require human intelligence — reasoning, learning, problem-solving, perception, and language understanding. Modern AI is predominantly powered by machine learning, particularly deep neural networks. The field encompasses Narrow AI (task-specific), General AI (AGI), and theoretical Superintelligence.

A hypothetical form of AI that can perform any intellectual task a human can — with comparable or superior breadth, depth, and adaptability. Unlike current narrow AI systems, AGI would generalize across all domains without retraining. The timeline and feasibility of AGI remain subjects of intense debate, with estimates ranging from years to never among leading researchers.

A neural network component that allows a model to dynamically focus on the most relevant parts of an input sequence when producing each output. Self-attention, the variant used in Transformers, computes pairwise relevance scores between all tokens in a sequence simultaneously — enabling models to capture long-range dependencies that earlier recurrent networks struggled with. The paper "Attention Is All You Need" (Vaswani et al., 2017) formalized this architecture.

A neural network architecture trained to compress input data into a compact latent representation (encoding) and then reconstruct it (decoding). Autoencoders are used for dimensionality reduction, anomaly detection, and as components in generative models. Variational Autoencoders (VAEs) extend the concept to generate novel samples by sampling from a learned probability distribution in the latent space.

Automated Machine Learning — the use of algorithms to automate the end-to-end process of applying ML, including data preprocessing, feature engineering, model selection, hyperparameter tuning, and architecture search. Tools like Google AutoML, H2O, and AutoKeras democratize ML by enabling practitioners without deep expertise to build high-performing models.

Any text, image, audio, video, or code produced by an AI model rather than authored directly by a human. AIGC spans blog posts written by ChatGPT, images from Midjourney, music from Suno, and synthetic video from Sora. The rise of AIGC has prompted policy debates around disclosure, copyright, and authenticity verification through provenance tools like watermarking and C2PA standards.

A standardized interface that allows software applications to communicate with each other. In the AI context, APIs (e.g., OpenAI API, Anthropic API, Gemini API) let developers integrate LLM capabilities into their own products by sending HTTP requests with prompts and receiving generated text or structured data in response. Most AI tool providers expose their models via REST APIs billed per token.

The algorithm used to train neural networks by computing the gradient of the loss function with respect to each model parameter and propagating errors backwards through the network layers. Combined with gradient descent, backpropagation enables the model to adjust weights iteratively, minimizing prediction error. It is the cornerstone of deep learning optimization.

Bidirectional Encoder Representations from Transformers — Google's 2018 breakthrough model that reads text bidirectionally (left-to-right AND right-to-left simultaneously), dramatically improving contextual understanding. BERT excelled at classification, question answering, and named entity recognition tasks. While superseded for generation, BERT-family models (RoBERTa, DeBERTa) remain widely used for embedding and retrieval tasks.

The systematic evaluation of AI model performance against standardized datasets and metrics. Common benchmarks include MMLU (general knowledge), HumanEval (coding), MATH (mathematical reasoning), GSM8K (grade-school math), and HellaSwag (commonsense reasoning). Benchmark saturation — models overfitting to test sets — is an ongoing challenge in fair model comparison.

The technique of grouping multiple inference requests together and processing them simultaneously rather than sequentially, improving GPU utilization and reducing per-request cost. Most LLM API providers offer batch APIs (e.g., OpenAI Batch API) that process large volumes of requests at 50% lower cost in exchange for longer latency windows (up to 24 hours).

A large neural network trained on broad, general data (e.g., web text, code, books) without task-specific fine-tuning or alignment training. Base models are the raw foundation upon which instruction-tuned, RLHF-aligned, and domain-specific models are built. They can complete text with high statistical coherence but lack instruction-following behavior without further training.

A prompting technique where the model is instructed to reason through a problem step-by-step before producing a final answer. Introduced by Wei et al. (2022), CoT dramatically improves accuracy on multi-step arithmetic, logic, and commonsense reasoning tasks. Variants include Zero-Shot CoT ("Let's think step by step"), Few-Shot CoT (providing worked examples), and Self-Consistency CoT (sampling multiple reasoning paths).

The maximum number of tokens an LLM can process simultaneously — encompassing both the input (system prompt + user messages + retrieved documents) and the generated output. Modern models range from 8K tokens (GPT-3.5) to 1 million+ tokens (Gemini 1.5 Pro). A larger context window enables document-level comprehension, long conversation memory, and entire codebases as input. Tokens are roughly 0.75 words for English text.

Anthropic's alignment technique where an AI is trained to critique and revise its own outputs according to a set of written principles ("a constitution"), reducing the need for human labeling of harmful content. The model first generates a response, then evaluates it against principles like "avoid harmful, deceptive, or discriminatory content," revises accordingly, and is then trained with RLHF using this self-critique signal. Powers Claude's safety behavior.

The field of AI that enables machines to interpret and understand visual information from images and video. Tasks include image classification (what is this?), object detection (where are the objects?), semantic segmentation (pixel-level labeling), and image generation. Modern CV is dominated by Vision Transformers (ViT) and convolutional neural networks (CNNs), with multimodal LLMs now bridging vision and language.

NVIDIA's parallel computing platform and API that enables GPU-accelerated computation, essential for training and running large AI models. CUDA allows thousands of GPU cores to perform matrix multiplications simultaneously — the core mathematical operation in neural networks. Virtually all modern deep learning frameworks (PyTorch, JAX, TensorFlow) use CUDA as their GPU backend.

A supervised machine learning task where the model assigns input data to one of a predefined set of categories. Binary classification (spam/not spam) uses two classes; multi-class classification (e.g., sentiment: positive/neutral/negative) uses more. Metrics include accuracy, precision, recall, F1 score, and AUC-ROC. Modern LLMs reframe many classification tasks as text generation problems.

An unsupervised learning method that groups data points into clusters based on similarity, without predefined labels. Common algorithms include K-Means, DBSCAN, and hierarchical clustering. In AI tools, clustering is used to group user queries, organize document collections, and discover latent topic structures. Embedding models enable semantic clustering of text.

An AI assistant embedded into a productivity tool that provides contextual suggestions, completions, and automation. Most famously, GitHub Copilot offers AI-powered code completion powered by OpenAI Codex. Microsoft has extended the "Copilot" brand to Microsoft 365 (Word, Excel, Outlook). The term has become a product category, signifying an AI that works alongside humans rather than replacing them.

The most common loss function for classification and language modeling tasks. It measures the difference between the model's predicted probability distribution and the true distribution (ground truth labels). For LLMs, cross-entropy loss is computed over next-token predictions during pre-training — lower loss means the model assigns higher probability to the correct next token.

AI tools and techniques applied to creative domains — writing, visual art, music composition, game design, and storytelling. Creative AI encompasses text-to-image models (Midjourney, DALL-E, Stable Diffusion), AI music generators (Suno, Udio), AI writing assistants (Jasper, Copy.ai), and AI video generators (Sora, Runway). Debates around originality, authorship, and copyright infringement remain active.

A subset of machine learning using neural networks with many layers (hence "deep") to learn hierarchical representations of data. Each layer learns increasingly abstract features — edges → shapes → objects in computer vision; characters → words → grammar → meaning in NLP. Deep learning's dominance since 2012 (AlexNet's ImageNet win) has powered nearly every major AI advance, from speech recognition to LLMs.

A class of generative models that learn to create data by iteratively denoising random Gaussian noise. During training, noise is progressively added to images (forward diffusion); the model learns the reverse process — predicting and removing noise step by step. Diffusion models power Stable Diffusion, DALL-E 3, and Midjourney, producing state-of-the-art image quality surpassing older GAN-based approaches.

The process of collecting, cleaning, filtering, deduplicating, and annotating training data for AI models. Data quality profoundly impacts model performance — "garbage in, garbage out" applies acutely to large-scale AI training. Modern LLM datasets (e.g., The Pile, RedPajama, DCLM) involve trillions of tokens filtered for quality, toxicity, and copyright compliance.

A tree-structured supervised learning model that splits data at each node based on feature thresholds, arriving at predictions at leaf nodes. Decision trees are interpretable but prone to overfitting. Ensemble methods like Random Forests (many trees voting) and Gradient Boosted Trees (XGBoost, LightGBM) combine multiple trees for significantly stronger, production-grade performance on structured/tabular data.

A computer system designed to engage in multi-turn conversations with humans, combining natural language understanding (NLU), dialogue management, and natural language generation (NLG). Modern dialogue systems are predominantly LLM-based. Architectures range from simple intent-slot matching (rule-based) to fully generative neural systems that can handle open-domain conversation, task completion, and emotional nuance.

Techniques that reduce the number of features in a dataset while preserving essential structure and variance. Linear methods like PCA (Principal Component Analysis) find orthogonal directions of maximum variance. Non-linear methods like t-SNE and UMAP preserve local cluster structure, making them popular for visualizing high-dimensional embedding spaces in 2D or 3D.

Synthetic media (video, audio, images) generated using deep learning to realistically depict real people saying or doing things they never did. Originally enabled by GANs, deepfakes are now increasingly powered by diffusion models and talking-head synthesis networks. While having legitimate creative and entertainment applications, deepfakes raise serious concerns around disinformation, non-consensual pornography, and election manipulation.

Dense numerical vector representations of text (or other data) that encode semantic meaning in a high-dimensional space. Similar concepts are geometrically close: "king" and "queen" have vectors that differ in a predictable "royalty" direction. Embeddings power semantic search, RAG retrieval, recommendation systems, and text clustering. Leading embedding models include OpenAI's text-embedding-3, Cohere Embed, and BGE series.

Experience, Expertise, Authoritativeness, Trustworthiness — Google's quality framework for evaluating content. E-E-A-T signals influence how AI Overviews and LLMs cite and surface content. Demonstrated by author credentials, first-hand experience, accurate factual claims, transparent sourcing, and secure, professional web presence. Sites publishing AI tool reviews and glossaries should explicitly surface author expertise and cite authoritative sources.

A machine learning paradigm that combines multiple models to produce stronger predictions than any individual model. Key techniques: Bagging (training models on random data subsets; Random Forests), Boosting (sequentially training models to correct prior errors; XGBoost), and Stacking (training a meta-model on base model outputs). Ensembles dominated structured data competitions (Kaggle) before deep learning, and remain strong baselines.

One complete pass through the entire training dataset during model training. Models are typically trained for multiple epochs, with weights updated at each step via backpropagation. Too few epochs = underfitting (model hasn't learned enough); too many = overfitting (model memorizes training data). Early stopping monitors validation loss to halt training at the optimal epoch automatically.

Structured tests used to measure LLM performance, safety, and alignment across specific tasks or behaviors. Evals range from automated benchmarks (MMLU, MT-Bench) to model-graded assessments (using GPT-4 to score outputs) to human expert annotation. ARC Evals and Anthropic's safety evaluations test models for dangerous capabilities. Running evals before and after fine-tuning is a deployment best practice.

The capacity of an AI model to provide human-understandable explanations for its predictions and decisions. Explainability methods include SHAP (feature attribution values), LIME (local linear approximations), and attention visualization. XAI is critical for regulated industries (healthcare, finance, legal) where "black box" decisions are unacceptable. Chain-of-thought prompting provides a form of reasoning transparency in LLMs.

Continuing to train a pre-trained model on a smaller, domain-specific dataset to adapt its behavior for a particular task or style. Full fine-tuning updates all model weights (expensive). PEFT (Parameter-Efficient Fine-Tuning) methods like LoRA and QLoRA update a small fraction of parameters, dramatically reducing compute requirements. Supervised Fine-Tuning (SFT) on instruction-response pairs is the first step in RLHF alignment pipelines.

A large AI model trained on broad, diverse datasets (text, code, images, video) at unprecedented scale, serving as a base for a wide range of downstream applications. Term coined by Stanford HAI in 2021. Foundation models exhibit emergent capabilities — abilities not explicitly trained for that arise from scale. GPT-4, Claude 3, Gemini Ultra, and Llama 3 are all foundation models.

A prompting strategy where a small number of input-output example pairs (typically 2–10) are included in the prompt to demonstrate the desired task format and behavior to the model. Few-shot prompting harnesses the LLM's in-context learning ability without requiring any weight updates or fine-tuning. Fewer examples = "one-shot"; no examples = "zero-shot".

The principle that AI systems should produce equitable outcomes across different demographic groups. Multiple competing mathematical definitions exist: demographic parity (equal selection rates), equalized odds (equal error rates), and individual fairness (similar people treated similarly). Impossibility theorems show these definitions cannot all be satisfied simultaneously, making fairness an inherently value-laden design choice.

The process of transforming raw data into informative input representations (features) that improve model performance. Traditionally required significant domain expertise and manual effort — the dominant bottleneck before deep learning automated representation learning. For structured/tabular data, feature engineering remains a key differentiator. LLMs and embedding models have largely automated feature extraction for unstructured text and images.

A generative model architecture (Goodfellow et al., 2014) consisting of two competing networks: a generator that creates synthetic data and a discriminator that distinguishes real from fake. Adversarial training drives both networks to improve until the generator produces indistinguishable outputs. GANs powered early high-fidelity image synthesis (StyleGAN, ProGAN) before being largely superseded by diffusion models in image quality benchmarks.

AI systems capable of creating new, original content — text, images, audio, video, 3D models, code, and synthetic data — by learning the statistical patterns of existing data. The generative AI wave (2022–present) was triggered by the public release of ChatGPT, Midjourney, and Stable Diffusion. Underlying architectures include Transformers (text), Diffusion models (images/video), and hybrid multimodal systems.

OpenAI's flagship LLM series, starting with GPT-1 (2018) and culminating in GPT-4o (2024). GPT models use a decoder-only Transformer architecture, pre-trained to predict the next token across massive web text corpora. GPT-3 (175B parameters) demonstrated remarkable few-shot capabilities; GPT-4 introduced multimodality. The GPT API powers thousands of AI products via OpenAI's platform.

The optimization algorithm used to minimize the loss function during neural network training. It iteratively adjusts model weights in the direction that reduces loss, guided by the gradient computed via backpropagation. Variants include Stochastic Gradient Descent (SGD) (one sample at a time), Mini-batch GD (small batches), and adaptive methods like Adam and AdamW which adjust the learning rate per parameter.

A massively parallel processor originally designed for rendering graphics, now the primary hardware for training and running AI models. GPUs excel at matrix multiplications, the core computation in neural networks. NVIDIA's A100 and H100 GPUs are the workhorse of LLM training. A single H100 costs ~$40,000; training frontier LLMs requires thousands of GPUs running for months, with total training costs reaching tens to hundreds of millions of dollars.

Safety systems, filters, and constraints applied to AI model inputs and outputs to prevent harmful, off-topic, or policy-violating content. Guardrails can be implemented at the model level (through alignment training), the API level (moderation endpoints), or the application level (custom rules). Frameworks like NVIDIA NeMo Guardrails and LangChain's content moderation modules provide programmable guardrail infrastructure for LLM applications.

When a generative AI model confidently produces output that is factually incorrect, fabricated, or nonsensical — stated with the same fluency and confidence as accurate information. Hallucinations stem from the model's statistical next-token prediction objective, which optimizes for plausibility rather than truth. Mitigation strategies include RAG (grounding in retrieved documents), self-consistency sampling, uncertainty estimation, and factuality fine-tuning.

Configuration settings that govern the training process, distinct from model parameters (weights) learned from data. Key hyperparameters include learning rate, batch size, number of layers, hidden dimension size, dropout rate, and number of training epochs. Hyperparameter tuning (via grid search, random search, or Bayesian optimization) is critical for maximizing model performance and is a major focus of AutoML systems.

An AI system design where humans are incorporated into the decision-making or training pipeline, either to validate outputs, provide labels (data annotation), or approve high-stakes actions before execution. HITL is central to RLHF (human feedback training), active learning (labeling the most informative samples), and agentic AI deployment (human approval before consequential actions).

The leading open-source AI platform and community hub for sharing, discovering, and deploying machine learning models, datasets, and demos. Hugging Face hosts 500,000+ pre-trained models via its Model Hub and provides the Transformers library — the most widely used Python library for working with LLMs. Key infrastructure for the open-source AI ecosystem.

The emergent LLM ability to learn patterns and perform new tasks from examples provided directly within the prompt, without updating model weights. ICL is the foundation of few-shot prompting — by showing the model input-output examples, it "learns" the task within the context window. This phenomenon emerges at scale and is a defining characteristic separating large foundation models from smaller task-specific ones.

The process of running a trained model on new inputs to generate predictions or outputs. In LLMs, inference means generating text tokens one at a time (autoregressive decoding) given a prompt. Inference is computationally intensive and typically requires GPU acceleration. Inference optimization techniques — including quantization, speculative decoding, and KV caching — are a major active research area to reduce latency and cost.

A fine-tuning technique that trains LLMs on a large collection of (instruction, desired output) pairs across diverse tasks — making models better at following natural language directions. Instruction-tuned models like FLAN-T5, InstructGPT, and Llama-Instruct dramatically outperform base models on real-world tasks. Combined with RLHF, instruction tuning is the recipe for producing useful AI assistants from raw pre-trained models.

The hardware and software stack for efficiently serving AI model predictions at scale. Includes GPU clusters, serving frameworks (vLLM, Text Generation Inference, ONNX Runtime), load balancing, batching strategies, and monitoring. Optimizing inference infrastructure is critical for production AI products — even a 10ms latency reduction translates to significant cost savings and user experience improvements at scale.

A computer vision task that assigns a label or category to an input image. Classic benchmarks include ImageNet (1000 object classes) and CIFAR-10. Deep learning transformed the field in 2012 when AlexNet reduced ImageNet error from 26% to 15% using a CNN. Modern Vision Transformers (ViT) and multimodal models like CLIP now perform zero-shot image classification using natural language descriptions as class labels.

Crafting adversarial prompts that bypass an LLM's safety guardrails, causing it to produce harmful, policy-violating, or restricted content. Common jailbreak techniques include role-play framing ("pretend you are an AI with no restrictions"), hypothetical scenarios, character injection, and multilingual exploits. Jailbreaking is distinct from prompt injection (manipulating the model to override its system prompt via malicious user content in agentic pipelines).

A structured output feature offered by LLM APIs (OpenAI, Anthropic, Gemini) that constrains the model to produce valid JSON rather than free-form text. Essential for building reliable LLM-powered applications that parse model outputs programmatically. Structured output mode (more advanced, using a specified JSON Schema) ensures the output matches a precise data structure, enabling robust agentic tool-use and data extraction workflows.

An inference optimization that stores the computed key and value matrices from the attention mechanism for previously processed tokens, so they don't need to be recomputed for each new token during autoregressive generation. KV caching is fundamental to making LLM inference practical — without it, generating each token would require full recomputation over the entire context. Large KV caches require significant GPU memory, creating a key constraint in long-context inference.

A model compression technique where a smaller "student" model is trained to mimic the output distributions (soft labels) of a larger "teacher" model, rather than just hard ground-truth labels. Distillation transfers the teacher's learned knowledge more efficiently than retraining from scratch. Used to create efficient, deployable models like DistilBERT (60% smaller than BERT, 97% of its performance) and small Llama variants.

The latest date represented in an LLM's training data, beyond which the model has no knowledge of events, papers, or developments. A model with a January 2024 cutoff cannot know about anything that happened after that date. Knowledge cutoffs are a key driver of hallucination on current-events questions. RAG and web search tool integrations are the primary solutions, allowing LLMs to access up-to-date information at inference time.

A diffusion model variant that performs the diffusion process in a compressed latent space (via a pre-trained VAE encoder) rather than pixel space — dramatically reducing computational cost while preserving image quality. Stable Diffusion is the most prominent LDM. Operating in latent space makes training ~10x cheaper than pixel-space diffusion, enabling open-source distribution of powerful image generation models.

A deep neural network with billions to trillions of parameters trained on massive text corpora to understand and generate human-like language. LLMs predict the next token autoregressively, producing coherent text. Scaling laws show that model capability improves predictably with more parameters and training data. Frontier LLMs include GPT-4o (OpenAI), Claude 3.5 (Anthropic), Gemini 1.5 Pro (Google), and Llama 3 (Meta).

A parameter-efficient fine-tuning (PEFT) technique that inserts small trainable low-rank matrices alongside frozen pre-trained weight matrices. Instead of updating billions of full model weights, LoRA trains only a fraction (often <1%) of parameters, reducing GPU memory requirements by 10–100x while maintaining near-full fine-tuning quality. QLoRA extends LoRA to quantized 4-bit models, enabling LLM fine-tuning on consumer GPUs.

A popular open-source Python and JavaScript framework for building LLM-powered applications. LangChain provides abstractions for chaining prompts, integrating tools and memory, building RAG pipelines, and orchestrating multi-step agentic workflows. Widely used for prototyping — though some teams switch to lower-level SDKs (LlamaIndex, Haystack, or direct API calls) for production deployments requiring more control.

A mathematical function that quantifies the difference between a model's predictions and the true targets, providing the training signal for gradient descent. Common loss functions: Cross-entropy (classification/LM), MSE (regression), KL divergence (distribution matching in RL/VAEs). The choice of loss function encodes what the model optimizes for and critically shapes its behavior — misspecified loss functions lead to Goodhart's Law failures.

Meta's open-weight LLM series, starting with Llama 1 (2023) and continuing through Llama 3.1 (405B parameters, 2024) and beyond. Llama models are released with weights available for research and commercial use, catalyzing an enormous open-source ecosystem of fine-tuned variants (Alpaca, Vicuna, Mistral) and local inference tools (Ollama, llama.cpp). Llama 3.1 405B performs comparably to GPT-4 on many benchmarks while remaining open-weight.

The compressed, abstract mathematical space where a model encodes its learned representations of data. In VAEs and diffusion models, the latent space is where generation occurs — sampling a point in latent space and decoding it produces an output. Semantically similar concepts occupy nearby regions: interpolating between two latent vectors produces a smooth blend of their corresponding outputs, a property exploited in image editing and style transfer.

A subset of AI where algorithms learn patterns from data to make predictions or decisions without explicit rule programming. ML encompasses supervised learning (labeled data → predictions), unsupervised learning (discovering structure in unlabeled data), semi-supervised learning (combination), and reinforcement learning (learning through reward signals). Deep learning is a subset of ML using multi-layered neural networks.

AI systems that process and generate multiple data modalities — text, images, audio, video, and code — within a single model. Modern multimodal models like GPT-4o, Gemini 1.5, Claude 3, and LLaVA can analyze images, transcribe audio, describe video, and reason across modalities simultaneously. Multimodality is increasingly the baseline expectation for frontier AI models.

Anthropic's open standard (2024) for connecting AI models to external tools, data sources, and services via a unified protocol. MCP servers expose tools and resources that LLMs can invoke; MCP clients (Claude, AI IDEs) connect to these servers. MCP has rapidly become an industry standard, enabling plug-and-play integration between AI assistants and services like GitHub, Slack, Google Drive, and custom databases without bespoke API integration for each.

A neural network architecture where the model contains many specialized "expert" sub-networks, with a gating mechanism routing each token to only a small subset (e.g., 2 of 16) of experts for processing. MoE enables much larger total model parameter counts while keeping per-token computation constant. Used in GPT-4 (speculated), Mixtral 8x7B, and Grok-1. Key to scaling beyond dense model limits efficiently.

An architecture where multiple AI agents collaborate, communicate, and divide work to accomplish complex tasks beyond a single agent's capability. Agents can have specialized roles (researcher, coder, critic, executor) and coordinate via a shared memory or message-passing protocol. Frameworks like AutoGen, CrewAI, and LangGraph provide infrastructure for building multi-agent pipelines. Multi-agent systems exhibit emergent problem-solving behaviors.

The Transformer mechanism that runs multiple self-attention operations in parallel ("heads"), each attending to different aspects of the input sequence simultaneously. Different heads can learn to focus on syntactic structure, semantic relationships, coreference, and topic coherence. The outputs of all heads are concatenated and projected, giving the model richer, multi-perspective contextual representations than a single attention head allows.

Techniques to reduce the size and computational cost of neural networks while preserving performance. Core methods: Quantization (reducing weight precision from FP32 to INT8/INT4), Pruning (removing low-importance weights), Knowledge Distillation (training a smaller student model), and Low-Rank Decomposition. Compression is critical for deploying AI on edge devices, mobile phones, and latency-sensitive production systems.

The subfield of AI focused on enabling computers to understand, interpret, and generate human language. NLP encompasses tasks including text classification, named entity recognition, machine translation, sentiment analysis, question answering, summarization, and text generation. The field was transformed by the Transformer architecture (2017) and subsequent LLMs, which unified most NLP tasks under a single pre-training paradigm.

A computational model loosely inspired by biological brain neurons, consisting of interconnected nodes (neurons) organized in layers. Input data flows through layers, with each neuron applying a weighted sum followed by a non-linear activation function. Deep neural networks (many layers) can learn extremely complex functions. Types include fully connected (dense), convolutional (CNN), recurrent (RNN), and attention-based (Transformer) networks.

The core pre-training objective of most LLMs: given a sequence of tokens, predict the most likely next token. Training on this simple objective across trillions of tokens causes LLMs to learn grammar, facts, reasoning patterns, and world knowledge as a byproduct. At inference time, LLMs generate text by repeatedly applying next-token prediction autoregressively, producing one token at a time until a stopping condition is met.

A prompting technique in image generation models (Stable Diffusion, Midjourney) that specifies what the model should avoid including in the output. Negative prompts are given alongside the positive (desired) prompt and guide the classifier-free guidance process away from unwanted elements: "blurry, low quality, extra limbs, watermark." Effective negative prompting significantly improves output quality and relevance.

Techniques that stabilize and accelerate neural network training by rescaling activations or weights within a defined range. Batch Normalization normalizes across a training batch, dramatically accelerating convergence in CNNs. Layer Normalization normalizes across the feature dimension per sample — preferred for Transformers and LLMs. RMSNorm (Root Mean Square) is a simplified, computationally efficient variant used in Llama and other modern LLMs.

A computer vision task that identifies and localizes multiple objects within an image, outputting bounding box coordinates and class labels for each detected object. Architectures include YOLO (You Only Look Once — real-time single-pass detection), Faster R-CNN (two-stage accuracy-focused), and DETR (Transformer-based end-to-end detection). Used in autonomous vehicles, medical imaging, retail analytics, and surveillance.

When a model learns the training data too well — including its noise and idiosyncrasies — and fails to generalize to unseen data. Overfitting is indicated by low training loss but high validation/test loss. Regularization techniques to prevent overfitting include dropout, weight decay (L2 regularization), data augmentation, early stopping, and ensembling. Underfitting is the opposite: the model is too simple to capture real patterns.

AI models whose trained weights are publicly released, allowing anyone to download, run, fine-tune, and deploy them (often with licensing restrictions). Distinguished from fully open-source models (where training code, data, and architecture are all public). Key open-weight models: Llama 3 (Meta), Mistral, Gemma (Google), Phi-3 (Microsoft), DeepSeek R1. Open-weight models enable local inference, privacy-preserving deployment, and customization.

The coordination and management of multiple AI model calls, tool invocations, and data flows within a complex pipeline or agentic workflow. An orchestrator sequences tasks, routes outputs between models and tools, manages memory/state, handles errors, and decides when to invoke human review. Frameworks: LangChain, LangGraph, LlamaIndex, Haystack, AutoGen, and Anthropic's Claude computer use. Critical for production-grade agentic AI applications.

The learnable numerical values (weights and biases) in a neural network, adjusted during training to minimize the loss function. A model's parameter count is a rough proxy for its capacity and capability — GPT-3 has 175B, GPT-4 is estimated at 1T+. Parameter count determines memory requirements: a 7B parameter model in FP16 precision requires ~14GB GPU memory just to load. "Parameters" and "weights" are often used interchangeably.

A family of techniques that fine-tune large pre-trained models by updating only a small subset of parameters, dramatically reducing compute and memory requirements compared to full fine-tuning. Methods include LoRA/QLoRA (low-rank weight updates), Prefix Tuning (learning virtual prompt tokens), Prompt Tuning (input-layer soft prompts), and Adapter layers. PEFT makes LLM fine-tuning accessible on consumer hardware.

The discipline of designing, crafting, and iterating on text instructions (prompts) to elicit specific, high-quality outputs from AI language models. Techniques span simple instruction clarity, role assignment, chain-of-thought reasoning, few-shot examples, output format specification, and complex multi-step prompt chaining. Effective prompt engineering can unlock dramatically better model performance without any fine-tuning, but its necessity is diminishing as frontier models improve instruction-following.

The first stage of training large AI models — training on a massive, broad dataset (billions to trillions of tokens of web text, code, books) using a self-supervised objective like next-token prediction. Pre-training is computationally intensive and expensive, costing tens of millions of dollars for frontier LLMs. The result is a base model with broad world knowledge and language capabilities that can be adapted via fine-tuning for specific tasks.

A metric for evaluating language model quality, measuring how well the model predicts a held-out text sample. Mathematically, perplexity is the exponentiated average negative log-likelihood per token — lower perplexity means the model is better at predicting the test data. A perplexity of 20 means the model is, on average, as confused as if choosing uniformly among 20 options at each step. Used for comparing models on the same tokenization scheme.

Paired evaluation metrics for classification models. Precision = (True Positives) / (True + False Positives) — of all positive predictions, how many were correct? Recall = (True Positives) / (True Positives + False Negatives) — of all actual positives, how many did the model find? The F1 score is their harmonic mean, balancing both. The precision-recall tradeoff is a fundamental consideration in deploying classifiers in production.

Reducing the numerical precision of model weights (and/or activations) from 32-bit or 16-bit floating point to 8-bit integers (INT8) or 4-bit (INT4), dramatically reducing memory and compute requirements at minimal quality cost. GPTQ, AWQ, and GGUF are popular quantization formats for LLMs. A 7B model quantized to 4-bit fits in ~4GB VRAM, enabling deployment on consumer-grade GPUs and even CPUs via llama.cpp.

A model-free reinforcement learning algorithm that learns the value (Q-value) of taking an action in a given state, enabling an agent to derive an optimal policy through trial-and-error interaction with an environment. Deep Q-Networks (DQN) combine Q-learning with neural networks, enabling superhuman performance in Atari games (DeepMind, 2015) and forming a foundation for modern RL research applied to LLM training (RLHF).

A combination of 4-bit quantization and LoRA that enables fine-tuning of very large LLMs (65B+ parameters) on a single consumer GPU (24–48GB VRAM). Introduced by Dettmers et al. (2023), QLoRA maintains near-full fine-tuning quality while reducing memory requirements by ~10x. QLoRA democratized LLM fine-tuning for individuals and small teams without access to multi-GPU clusters.

An architecture combining an LLM with a retrieval system that fetches relevant documents from an external knowledge base and includes them in the prompt as context. RAG addresses the key limitations of standalone LLMs: knowledge cutoffs and hallucination. The pipeline: embed the query → retrieve top-k similar documents from a vector database → inject retrieved passages into the prompt → generate a grounded response. RAG is the dominant architecture for enterprise AI chatbots and Q&A systems.

A prompting framework (Yao et al., 2022) that interleaves reasoning traces ("Thought") with external actions ("Act") and observations ("Obs"), enabling LLMs to dynamically plan and execute multi-step tasks using tools. ReAct dramatically improves agent performance on complex tasks requiring web search, database queries, and code execution. It forms the conceptual basis for most modern LLM agent implementations.

A machine learning paradigm where an agent learns to make decisions by taking actions in an environment and receiving reward or penalty signals. The agent aims to maximize cumulative reward over time by learning an optimal policy. RL has achieved superhuman performance in games (AlphaGo, Dota 2), and is central to RLHF — the training technique that aligns LLMs with human preferences by treating human feedback as reward signals.

The training methodology that transforms base LLMs into helpful, harmless assistants. RLHF involves three stages: (1) supervised fine-tuning (SFT) on demonstration data, (2) training a reward model from human pairwise preference comparisons, and (3) using RL (typically PPO) to fine-tune the LLM to maximize the reward model's score. RLHF was central to InstructGPT and ChatGPT's breakthrough helpfulness and safety.

A supervised machine learning task where the model predicts a continuous numerical output rather than a discrete category. Examples: predicting house prices, stock returns, or user engagement scores. Linear regression is the simplest form; deep neural networks extend regression to complex, non-linear relationships. In the LLM era, many regression tasks are reframed as text generation (e.g., "What is the sentiment score from 0–10?").

Techniques that prevent neural network overfitting by adding constraints or noise to the training process. L1/L2 weight decay penalizes large weights in the loss function. Dropout randomly zeroes out neurons during training, forcing redundant representations. Data augmentation artificially increases training diversity. Early stopping halts training when validation performance plateaus. Together, regularization methods are fundamental to building models that generalize.

Empirical relationships showing that LLM performance improves predictably as a power-law function of model size, training data volume, and compute budget. The Chinchilla scaling laws (Hoffmann et al., 2022) showed most models were over-parameterized relative to their training data — recommending equal scaling of parameters and tokens. Scaling laws enable planning training runs before execution, predicting final performance at different compute budgets.

Search that understands the meaning of a query rather than matching exact keywords. Enabled by embedding models that project queries and documents into the same vector space — retrieval finds documents with the highest cosine similarity to the query embedding. Semantic search powers modern RAG pipelines, enterprise knowledge bases, and AI-enhanced site search. Contrasts with BM25/TF-IDF keyword search, which matches surface-level term overlap.

An initial instruction set provided to an LLM by the application developer (not the end user) that establishes the model's persona, behavior guidelines, capabilities, and constraints for the entire session. System prompts are processed before user messages and are typically not visible to users. They are the primary mechanism by which AI products customize LLM behavior — setting tone, domain focus, safety rules, output format, and access to tools.

An open-source latent diffusion model (Stability AI, 2022) for text-to-image generation, notable as the first high-quality, openly available image generation model. Stable Diffusion democratized generative art by enabling local GPU inference and community fine-tuning. The ecosystem includes SDXL, SD 3.0, ControlNet (pose/depth guidance), LoRA fine-tunes, and ComfyUI workflows. It spawned a massive commercial and creative tool ecosystem.

The most common machine learning paradigm, where models learn from a dataset of labeled (input, output) pairs. The model learns a mapping function from inputs to outputs, minimizing prediction error on training examples. Classification and regression are the two primary supervised tasks. Supervised learning requires significant labeled data — a key bottleneck that self-supervised pre-training (used in LLMs) elegantly circumvents by using the data itself as labels.

A learning paradigm where the model generates its own supervisory signal from unlabeled data — e.g., LLMs trained to predict masked or next tokens from raw text, or CLIP trained to match images with their text descriptions. Self-supervised learning enables training on the virtually unlimited unlabeled data available on the internet, bypassing the expensive human annotation bottleneck of supervised learning. It underlies most modern foundation models.

AI technology that converts text into natural-sounding spoken audio. Modern neural TTS systems (ElevenLabs, OpenAI TTS, PlayHT, Kokoro) produce near-human voice quality, can clone voices from short audio samples, and control prosody (intonation, emphasis, pacing). TTS is a core component in voice assistants, audiobook creation, accessibility tools, and AI avatars. Zero-shot voice cloning (reproducing any voice from seconds of audio) is now commercially available.

A parameter controlling the randomness/creativity of LLM text generation. At temperature = 0, the model always selects the highest-probability token (deterministic, highly consistent). Higher temperatures (0.7–1.5) increase diversity by flattening the probability distribution — more creative, varied outputs with higher risk of errors. For factual tasks (code, data extraction), low temperatures are preferred; creative writing benefits from moderate-high temperatures.

The process of breaking input text into discrete units called tokens for processing by an LLM. Modern tokenizers (e.g., BPE — Byte Pair Encoding, SentencePiece) split text at the subword level, handling rare words and multiple languages efficiently. For English, 1 token ≈ 0.75 words. Tokenization affects cost (API billing is per-token), context window capacity, and model behavior on different languages and code.

The basic unit of text that LLMs process. Tokens can be full words ("hello"), subword fragments ("tokeniz"), punctuation, whitespace, or special characters. The sentence "Artificial intelligence is transforming technology" is approximately 7 tokens. Token count determines API cost (models bill per input + output token), context window capacity, and generation length. 1,000 tokens ≈ 750 words for typical English text.

The ability of LLMs to identify when an external tool (calculator, web search, database query, API call, code interpreter) should be invoked, generate the appropriate function call with parameters, and integrate the tool's result into its response. Function calling, introduced by OpenAI in 2023, transformed LLMs from text generators into active agents capable of taking real-world actions. Now supported natively by all major LLM APIs.

The technique of applying knowledge gained from training on one task to a different but related task. In deep learning, a model pre-trained on a large dataset (e.g., ImageNet for vision, web text for LLMs) is fine-tuned on a smaller target dataset. Transfer learning is the dominant paradigm in modern AI — pre-training once on broad data and adapting cheaply to specific tasks is far more efficient than training task-specific models from scratch.

The neural network architecture introduced in "Attention Is All You Need" (Vaswani et al., 2017) that replaced recurrent networks for NLP and became the foundation of virtually all modern LLMs. Key innovations: self-attention (processing all tokens in parallel), positional encoding (injecting sequence order), and deep residual feed-forward layers. Encoder-only (BERT), decoder-only (GPT), and encoder-decoder (T5) variants suit different tasks.

A prompting framework (Yao et al., 2023) that extends chain-of-thought by enabling LLMs to explore multiple reasoning branches simultaneously and backtrack when necessary — mimicking tree search. The model generates several candidate "thought" steps, evaluates their promise, and expands the most promising branches. Tree of Thought dramatically improves performance on tasks requiring systematic planning and search, like puzzles, code planning, and multi-step mathematical reasoning.

The information used to teach an AI model — the corpus of examples from which it learns patterns, facts, and behaviors during the training process. For LLMs, training data typically comprises trillions of tokens from web crawls (Common Crawl), books, scientific papers, code repositories, and curated high-quality sources. The quality, diversity, coverage, and filtering of training data is one of the most impactful determinants of final model capability and behavior.

Machine learning on unlabeled data, where the algorithm discovers inherent patterns, structure, or representations without human-provided ground truth. Core unsupervised tasks: clustering (grouping similar items), dimensionality reduction (compressing feature spaces), and density estimation (learning data distributions). Self-supervised learning has largely superseded traditional unsupervised learning for deep representations, using data structure itself as supervision.

Uniform Manifold Approximation and Projection — a fast, scalable dimensionality reduction algorithm that preserves both local and global structure of high-dimensional data, outperforming t-SNE in speed and global consistency. Widely used to visualize LLM embedding spaces, discover clusters in document collections, and understand model representations. UMAP is the standard tool for "seeing" what's in a vector database or embedding model.

Quantifying how confident an AI model is in its predictions, distinguishing between well-known cases and uncertain edge cases. A well-calibrated model's confidence scores accurately reflect its actual accuracy. Uncertainty estimation is critical for high-stakes AI applications (medical diagnosis, autonomous driving) where knowing "when not to predict" is as important as the prediction itself. LLMs are often overconfident — a key driver of hallucination.

A specialized database designed to store, index, and search high-dimensional vector embeddings at scale using approximate nearest-neighbor (ANN) algorithms (HNSW, IVF-PQ). Essential infrastructure for RAG pipelines, semantic search, recommendation systems, and multimodal retrieval. Leading solutions: Pinecone (managed), Weaviate, Qdrant, Chroma (local/open-source), Milvus, and pgvector (PostgreSQL extension).

AI models that generate video clips from text descriptions, reference images, or existing video through temporal extension. OpenAI's Sora (2024) demonstrated high-fidelity, physically consistent minute-long video generation from text prompts. Other leaders: Runway Gen-3 Alpha, Kling, Luma Dream Machine, and Pika. Video generation combines spatial image diffusion with temporal consistency modeling, requiring 10–100x the compute of image generation.

A software development approach popularized by Andrej Karpathy (2025) where developers describe the desired functionality in natural language and let AI (Claude, GPT-4o, Cursor, etc.) write the actual code — with the developer guiding, accepting, or rejecting suggestions rather than writing syntax manually. Vibe coding dramatically lowers the barrier to building software, enabling non-programmers to create working applications. It represents a paradigm shift in how software is written.

A model architecture applying the Transformer mechanism directly to image classification by splitting images into fixed-size patches (16×16 pixels), flattening them into a sequence, and processing with self-attention. Introduced by Dosovitskiy et al. (2020), ViT matched and then surpassed CNNs on large datasets. ViT is the visual encoder in CLIP (enabling text-image matching) and forms the vision backbone of most modern multimodal LLMs.

Techniques for embedding detectable signals into AI-generated content (text, images, audio) to enable provenance verification and authenticity attribution. Cryptographic watermarks (C2PA standard, supported by Adobe, Microsoft, Google) embed verifiable metadata in media files. Statistical text watermarking subtly biases token selection during LLM generation to create detectable patterns. Used for AI content disclosure, copyright enforcement, and disinformation mitigation.

The numerical parameters learned during training that encode a model's knowledge and capabilities. In a neural network, weights are the multiplicative coefficients applied to inputs at each connection. An LLM's weights represent everything the model has learned from its training data — encoded in billions to trillions of floating-point numbers. When people refer to an "open-weight" model, they mean one where these trained parameters are publicly released for download.

The use of AI agents and LLMs to automate multi-step business processes — document processing, email triage, CRM updates, data extraction, report generation — that previously required human coordination. Tools like Zapier AI, Make, n8n, and Microsoft Power Automate integrate LLMs with thousands of apps and APIs. AI workflow automation is the fastest-growing enterprise AI use case by deployment volume.

An LLM's ability to perform a task described in natural language without any prior examples or demonstrations in the prompt. Zero-shot capability emerges from large-scale pre-training — the model generalizes from patterns learned during training to new, unseen tasks. Modern frontier models (GPT-4, Claude 3.5) are highly capable zero-shot performers across diverse tasks, though few-shot examples still improve performance on specialized domains.

Novel, previously unknown attack vectors targeting AI systems — prompt injections that bypass guardrails, adversarial inputs that cause misclassification, data poisoning attacks that corrupt model behavior, or jailbreaks that haven't been patched by safety training. As AI deployment scales, AI-specific zero-day vulnerabilities represent a growing cybersecurity frontier, prompting AI red-teaming programs at major labs (Anthropic, OpenAI, Google DeepMind) and emerging AI security startups.

A generation setting where temperature is set to 0, making the model choose the highest-probability token at each step. This yields highly deterministic and repeatable outputs, which is useful for structured extraction, code generation, and regression-style evaluation tasks.

A practical engineering target in AI product design where responses feel instant to users through aggressive optimization, token streaming, caching, and lightweight routing. While literal zero latency is impossible, reducing perceived latency is critical for conversational UX quality.

A security model that assumes no implicit trust between users, services, models, or data stores. In AI systems, zero-trust architecture enforces strict identity verification, least-privilege access, and continuous authorization checks for model endpoints, vector stores, and tool integrations.

A feature scaling method that transforms values to have mean 0 and standard deviation 1. Standardization improves optimization stability and convergence for many machine learning models, especially when input features are on different numeric scales.

An empirical law stating that word frequency in natural language is inversely proportional to rank. Zipfian distributions shape tokenizer design, long-tail vocabulary behavior, and sampling efficiency in language model training corpora.

An informal prompting pattern where contrasting examples are alternated to force clearer model boundaries (e.g., correct vs incorrect outputs). This style can improve consistency for classification and policy-constrained generation tasks.

A deployment strategy that routes agent requests by region, tenant, or compliance boundary to specific infrastructure zones. Zonal routing reduces latency and helps satisfy data residency requirements in enterprise AI systems.

A provider configuration where prompts and outputs are not stored for long-term model training or analytics. Zero-retention modes are used by regulated teams handling sensitive workloads and strict internal privacy requirements.

Cryptographic methods that allow one party to prove a claim without revealing the underlying secret. In AI ecosystems, zero-knowledge proofs are explored for model provenance, secure identity, and verifiable claims about training or inference without exposing sensitive data.

A prompt technique that first asks the model for higher-level strategy before details. By expanding context and goals up front, zoom-out prompting can produce more coherent plans and reduce local optimization errors in complex tasks.

A depth-buffering technique used in graphics pipelines to determine visible surfaces by storing depth values per pixel. In vision-adjacent workflows, depth maps and z-buffer concepts support 3D scene reconstruction and synthetic data generation.

A colloquial description of unstable gradient updates that oscillate around minima instead of converging smoothly. Common fixes include adaptive optimizers, momentum, better feature scaling, and improved learning-rate schedules.

A high-performance compression algorithm widely used to package model artifacts, logs, and datasets. Zstd can reduce transfer times and storage costs for checkpoints, evaluation traces, and intermediate preprocessing outputs.

A memory strategy inspired by linked-note systems, where an agent stores short atomic notes connected by references. This improves recall, traceability, and long-horizon planning compared to monolithic conversation histories.

A marketing claim that should be treated skeptically. Because all models inherit assumptions from data and objectives, practical fairness work focuses on measurable bias reduction, transparency, and continuous evaluation rather than absolute claims.

Workflow automation patterns where AI steps are embedded in trigger-action chains (often called zaps). These patterns connect LLM summarization, classification, and extraction to operational tools like CRMs, docs, and communication channels.

A classification approach where a model predicts labels it was not explicitly trained on by leveraging semantic understanding and natural-language label descriptions. Useful for fast taxonomy creation when labeled datasets are limited.

A phrase from media fiction often misapplied to AI imaging. Super-resolution models can improve perceptual detail, but they cannot reliably recover ground-truth information absent from the original signal.

A prompt structuring heuristic that places objective, constraints, context, and output format in a deliberate reading order to reduce ambiguity. Clear layout can materially improve output consistency in multi-requirement prompts.

A statistical test used to evaluate whether observed differences in model metrics are likely due to chance under assumptions about variance and sample size. It helps teams avoid over-interpreting small benchmark improvements.