Glossary

An LLM-driven system that reasons, plans, and takes actions (via tools) to achieve a goal autonomously.

Persistent memory stored across user sessions using vector databases or key-value stores.

Working memory held in the LLM context window during an active session (scratchpad and recent tool outputs).

Managing execution flow, state transitions, tool routing, and handoffs across single or multi-agent systems.

An agent's ability to break a high-level goal into an ordered sequence of structured sub-tasks before executing actions.

Structured message formats and protocols allowing independent agents to exchange data, status, and sub-tasks.

Steering an LLM's behavior so its actions, tone, and safety constraints match human values and intentions.

Algorithms that trade off a tiny fraction of accuracy to search millions of vectors 100x faster than brute-force comparisons.

Autonomous agents execute tasks end-to-end independently, while co-pilots work interactively alongside human supervision.

Prompting an LLM to output step-by-step intermediate reasoning out loud before giving its final answer.

Duplicating a small portion of text between adjacent chunks to prevent sentences or context from getting cut in half.

Splitting long documents into smaller text segments so retrieval can pull exact paragraphs rather than entire files.

Attaching exact source document metadata to generated answers so users can verify where claims originated.

Formatting and inserting retrieved document chunks into the LLM prompt right before generating an answer.

The degraded ability of an LLM to recall information located in the middle of long context windows compared to the top or bottom.

The maximum number of tokens an LLM can read and remember in a single request, including prompt and reply.

A mathematical formula measuring the angle between two vector arrows to determine how close their meanings are.

Retrieving documents based on semantic meaning using vector embeddings rather than matching exact words.

Training a small, efficient 'student' model to copy the outputs and performance of a massive 'teacher' model.

A dense vector (array of numbers) representing the meaning of text, allowing computers to compare concepts mathematically.

A specialized neural network designed to turn text strings into dense vector representations for similarity math.

An agent's record of specific past execution trajectories, successful action sequences, and past errors.

Evaluation metrics checking whether every claim made in an LLM output is strictly supported by retrieved context chunks.

Zero-shot asks the model to perform a task with no demonstrations; few-shot provides 1 to 5 example input/output pairs in the prompt.

Continuing training on a pretrained model using a curated dataset to adapt it for specialized tasks or domain jargon.

A JSON specification describing a tool's name, purpose, input parameters, and types so an LLM knows how to invoke it.

The LLM component in RAG that synthesizes a final answer using retrieved document chunks alongside the query.

Combining RAG with a structured knowledge graph to extract entities, relationships, and community summaries across complex datasets.

Decoding strategies where greedy picks the single top word each step, while beam search keeps multiple candidate paths active.

Linking LLM responses directly to verified external facts, documents, or data sources to prevent unbacked fabrications.

Input and output validation layers that enforce safety rules, topic boundaries, and formatting constraints.

When an LLM confidently outputs plausible-sounding information that is factually false, ungrounded, or fabricated.

A multi-layered graph algorithm used in vector databases for super-fast approximate vector similarity retrieval.

Pausing agent execution before sensitive actions to require explicit approval or input from a human operator.

Combining semantic vector search (dense) and keyword search (sparse) to catch both conceptual meaning and exact jargon.

Generating a hypothetical answer with an LLM first, embedding that fake answer, and using it to search for real matching documents.

The automated data ingestion flow that loads documents, splits them into chunks, embeds them, and uploads them to a database.

Fine-tuning a base model on prompt-and-response pairs so it follows user commands instead of just completing text.

The complete collection of raw documents, PDFs, manuals, and data files indexed by a RAG system.

Caching previously calculated Key and Value attention states in RAM so the model doesn't recompute earlier tokens for every new word generated.

The architectural reality that every extra agent thinking turn and tool invocation adds latency and token API costs.

Raw, unnormalized score outputs produced by an LLM for every word in its vocabulary before converting them into probabilities.

Parameter-efficient fine-tuning methods that freeze main model weights and only train tiny low-rank adapter matrices.

An open standard connecting LLM agents to local files, tools, and remote APIs using a unified client-server architecture.

Restricting vector searches using structured tags (like user ID, date range, or category) alongside embedding similarity.

An LLM architecture that routes each token to a small subset of specialized sub-networks ('experts') instead of running the whole model.

An architecture where multiple specialized LLM agents collaborate, share state, and delegate sub-tasks to accomplish complex goals.

Executing iterative search rounds where information retrieved in step 1 informs what query to run in step 2.

The repeating engine cycle where an agent thinks, takes an action, observes the result, and decides the next step.

A statistical metric measuring how surprised an LLM is by a sample of text — lower scores mean better predictions.

Numerical vectors added to token embeddings so the transformer knows the exact order of words in a sentence.

The initial, large-scale training phase where an LLM learns language patterns, facts, and logic by predicting missing words across billions of web pages.

Compressing model weights from high precision (16-bit floats) to lower precision (8-bit or 4-bit integers) to shrink memory size and boost speed.

Using an LLM to rephrase or expand a user query into multiple variations before retrieval to improve document recall.

Before answering, the system looks up relevant information from your own data — then hands that to the LLM so it answers using real facts instead of guessing from memory.

An agent prompting pattern that alternates between explicit reasoning steps ('Thought') and tool actions ('Action').

A workflow where an agent evaluates its own generated output, identifies errors, and revises its answer before finalizing.

A secondary pass using a specialized cross-encoder model to re-order initial retrieval candidates for higher accuracy.

Quantitative metrics measuring how accurately a retriever surfaces correct documents in top search positions.

The component in a RAG system that searches a database and fetches relevant document chunks for a query.

Training models using reward scores from human graders (RLHF) or AI evaluators (RLAIF) to ensure outputs are helpful, honest, and safe.

A formula for merging two ranked result lists (like keyword and vector search) into one combined ranking based on item position.

Executing agent-generated code or shell commands inside isolated containers to protect host infrastructure.

A calculation that lets an LLM weigh how relevant every word in a sequence is to every other word.

Splitting text wherever topic meaning shifts (detected via embedding distance drops) rather than arbitrary token counts.

Traditional keyword search (like BM25 or TF-IDF) that matches exact word occurrences and frequencies between query and documents.

Representing agent context as an explicit state object updated deterministically after each step or node execution.

A specialized agent with a targeted system prompt and restricted tools tasked with solving one specific sub-task.

A top-level routing agent that inspects incoming tasks, assigns them to specialized worker agents, and compiles final results.

Persistent baseline instructions provided to an LLM at startup to set its rules, persona, formatting constraints, and safety boundaries.

Dividing a large request into small, isolated sub-problems that can be executed independently or delegated to worker agents.

A parameter controlling how randomly an LLM selects its next word — low values produce deterministic facts, high values produce creative outputs.

Explicit rules that break an agent execution loop to prevent runaway API costs or infinite execution cycles.

Breaking raw text into smaller subword units (tokens) that an LLM converts into numbers to process.

The process where an LLM selects an available tool and outputs a structured request (JSON) to run external code instead of plain text.

Filtering methods that restrict next-word choices to either the K most likely words or the top pool adding up to cumulative probability P.

Configuring the exact number (K) of top-matching document chunks pulled from the index to pass to the generator or reranker.

The foundational neural network architecture behind modern LLMs that processes all words in parallel using self-attention.

A database engine specifically optimized to store embeddings and perform fast similarity searches.

Structuring agent execution as a directed graph where nodes perform actions and edges handle routing decisions.