Glossary · Category

Agents & harnesses

102 plain-English definitions.

agent framework: General term for a software library that provides the building blocks (loops, memory, tools) for constructing LLM-powered agents.
agent harness: The orchestration code around an LLM that manages prompts, tool calls, memory, and control flow to turn a base model into a working agent.
agent identity and permissions: The access control model that defines what systems and data an autonomous agent is authorized to act on.
agent loop: The repeating cycle of an agent observing state, reasoning, taking an action, and processing the result until a task is complete.
agent memory: The mechanisms (short-term context, long-term storage, retrieval) an agent uses to retain and recall information across steps or sessions.
agent scaffold: The structural framework (prompts, loop logic, tool definitions) an agent runs inside, distinct from the underlying model itself.
agent-computer interface (ACI): The design of tools, feedback formats, and affordances that let an AI agent effectively perceive and act on a computer environment.
agent-to-agent communication: Protocols and message formats that let independent AI agents exchange information or delegate tasks to each other.
Agent2Agent protocol (A2A): Google's open protocol for enabling AI agents built on different frameworks to discover and communicate with each other.
agentic coding: Using an AI coding agent to autonomously write, test, and debug software with minimal step-by-step human direction.
agentic loop control: The logic that determines when an agent should stop iterating, ask for help, or hand off to another process.
agentic RAG: Retrieval-augmented generation where an agent actively decides when, what, and how many times to retrieve, rather than retrieving once up front.
agentic search: Search behavior where an LLM autonomously issues, refines, and chains multiple queries rather than executing a single lookup.
agentic workflow: A multi-step process where an LLM makes decisions about what to do next, rather than following a fixed, human-scripted sequence.
AI agent: A system that uses an LLM to autonomously plan, decide, and take actions (often via tools) toward a goal, rather than just responding to a single prompt.
AutoGen: Microsoft's open-source framework for building multi-agent conversational AI applications.
autonomous agent: An agent that operates with minimal human intervention, making its own decisions across multiple steps toward a goal.
browser agent: An AI agent that navigates and interacts with web pages autonomously to complete tasks like form-filling or research.
chain-of-thought (CoT) prompting: Prompting a model to reason step by step before giving a final answer, which typically improves accuracy on complex tasks.
chunking strategy: The method used to split documents into smaller pieces before embedding and indexing them for retrieval.
CLI agent: An AI coding agent that runs primarily inside a command-line interface, reading and editing files and executing commands directly.
code interpreter: A tool that lets an LLM write and execute code in a sandboxed environment to perform calculations or data analysis.
coding agent: An AI agent that can read, write, and execute code autonomously to complete software engineering tasks.
computer use: An AI capability where a model can view a screen and control a mouse/keyboard to operate software the way a human would.
constrained decoding: Restricting a model's token generation at each step to only valid options according to a grammar or schema, guaranteeing structural correctness.
context compaction: Reducing the size of an agent's conversation history by summarizing older turns while preserving key information.
context engineering: The discipline of deliberately curating and structuring what information goes into an LLM's context window to maximize task performance.
contextual retrieval: A RAG technique that prepends chunk-specific context (generated by an LLM) to each document chunk before embedding, improving retrieval accuracy.
CrewAI: An open-source framework for orchestrating multiple role-based AI agents that collaborate on tasks.
deep research agent: An agent designed to autonomously conduct multi-step web research, synthesizing findings from many sources into a report.
DSPy: A framework for programmatically optimizing LLM prompts and pipelines by treating them as compilable, trainable programs.
dynamic tool loading: Letting an agent discover and load only the tools relevant to its current task at runtime instead of exposing every tool upfront.
embedding model: A model that converts text (or other data) into a dense numeric vector capturing its semantic meaning, used for search and retrieval.
episodic memory (agent): An agent's memory of specific past events or interactions, as opposed to general learned knowledge.
evaluator-optimizer pattern: An agentic workflow where one LLM call generates output and another critiques and refines it in a loop until quality criteria are met.
few-shot prompting: Providing a handful of example input-output pairs in the prompt to guide the model's response format and behavior.
function calling: The specific API feature (popularized by OpenAI) that lets a model output a structured JSON call to a predefined function based on the conversation.
function schema: The structured definition (name, parameters, types) describing a tool that an LLM can call.
grammar-constrained generation: Using a formal grammar (like a context-free grammar) to restrict what a model can output at each decoding step.
GraphRAG: A retrieval-augmented generation approach that builds and queries a knowledge graph extracted from source documents instead of (or alongside) plain vector search.
guardrails (agents): Constraints and checks placed around an agent's actions to prevent unsafe, out-of-scope, or policy-violating behavior.
human-in-the-loop: A workflow design where a human must review or approve certain AI agent actions before they're executed.
hybrid search: Combining keyword-based (lexical) search with vector-based semantic search to improve retrieval accuracy.
HyDE (hypothetical document embeddings): A retrieval technique that has an LLM generate a hypothetical answer first, then embeds that answer to search for similar real documents.
indirect prompt injection: A prompt injection attack delivered through a third-party data source (like a webpage or document) the model reads rather than the direct user input.
Instructor: A popular library for getting reliable structured outputs (Pydantic models) from LLMs via function calling.
jailbreaking: Techniques used to bypass an LLM's safety training and get it to produce disallowed content.
JSON mode: A model feature that forces the output to be syntactically valid JSON.
JSON schema validation: Checking that a model's structured output conforms to a predefined JSON Schema before it's used downstream.
knowledge graph RAG: Using a structured graph of entities and relationships as the retrieval source for grounding LLM responses.
LangChain: A popular open-source framework for building LLM applications by chaining together prompts, models, tools, and memory components.
LangGraph: A LangChain-affiliated framework for building agents as stateful graphs of nodes, useful for complex multi-step or multi-agent workflows.
late chunking: An embedding technique that runs the full document through the embedding model before splitting into chunks, preserving more contextual information than chunking first.
LlamaIndex: An open-source framework focused on connecting LLMs to external data through indexing and retrieval pipelines for RAG applications.
LLM firewall: A middleware layer that inspects and filters prompts and responses for security threats like prompt injection or data leakage.
long-term memory (agent): Persistent storage (often a vector or key-value store) an agent can write to and query across sessions.
MCP client: An application or agent that connects to and consumes tools/resources from an MCP server.
MCP server: A service that exposes tools, resources, or prompts to an LLM application using the Model Context Protocol.
memory compaction: Summarizing or pruning an agent's accumulated context/history to keep it within the model's context window.
Model Context Protocol (MCP): An open standard (from Anthropic) for connecting LLM applications to external tools, data sources, and systems through a common protocol.
multi-agent system: An architecture where multiple LLM agents with distinct roles collaborate, communicate, or compete to complete a task.
multi-hop retrieval: A retrieval strategy that chains several search steps together, where each step's results inform the next query, to answer questions requiring multiple facts.
orchestration layer: The software layer that coordinates calls to models, tools, and data sources to execute a multi-step LLM application.
orchestrator agent: A top-level agent that delegates subtasks to specialized worker agents and assembles their results.
plan-and-execute agent: An agent pattern that first produces a full multi-step plan, then executes each step, as opposed to deciding one action at a time.
planning (agentic): The step where an agent breaks a high-level goal down into an ordered sequence of subtasks before executing them.
PR review agent: An AI agent that automatically reviews pull requests, leaving comments or suggested fixes like a human code reviewer.
prompt chaining: Feeding the output of one LLM call as the input to another in a fixed sequence to break a task into simpler steps.
prompt engineering: The practice of designing and refining input prompts to reliably elicit desired behavior from an LLM.
prompt firewall: A protective layer that screens incoming prompts for injection attacks or policy violations before they reach the model.
prompt injection: An attack where malicious instructions embedded in input data (or a tool's output) manipulate an LLM into ignoring its original instructions.
query expansion: Augmenting a search query with related terms or synonyms to broaden retrieval coverage.
query rewriting (RAG): Reformulating a user's raw query into a better search query before running retrieval, to improve the relevance of returned documents.
ReAct pattern: An agent prompting technique that interleaves reasoning traces ("thought") with actions ("act") so the model can plan and use tools step by step.
reflection (agents): Having a model critique or review its own prior output and revise it, often improving accuracy on complex tasks.
reranking: A retrieval step that reorders an initial set of candidate documents using a more precise (often cross-encoder) model to improve final relevance.
retrieval-augmented generation (RAG): An architecture that retrieves relevant documents from an external knowledge base and feeds them into an LLM's context to ground its answer.
ReWOO pattern: An agent architecture that separates reasoning/planning from tool execution, generating a full plan before calling any tools to reduce token usage.
router agent: An agent whose sole job is to classify a request and hand it off to the correct specialized downstream agent or tool.
sandboxing (agents): Running an agent's code execution or tool actions in an isolated environment to contain any unintended side effects.
self-consistency: A reasoning technique that samples multiple chain-of-thought answers and takes the majority vote as the final result.
self-correction: An LLM technique where the model checks its own output for errors and fixes them before finalizing a response.
Semantic Kernel: Microsoft's SDK for integrating LLMs into applications with plugins, memory, and planning capabilities.
semantic search: Searching for content by meaning similarity between embeddings rather than exact keyword matches.
short-term memory (agent): An agent's working context within a single session or task, typically held in the active context window.
structured outputs: A model capability that constrains generation to conform to a specified schema (like JSON Schema), guaranteeing parseable output.
subagent: A specialized agent invoked by a parent/orchestrator agent to handle a specific piece of a larger task.
system prompt: The initial instruction set given to a model before user input, defining its role, constraints, and behavior for a session.
task decomposition: Breaking a complex objective into smaller, independently solvable subtasks, typically performed by a planning agent.
terminal agent: An AI agent that operates by issuing shell commands in a terminal to accomplish tasks like coding or system administration.
tool calling: An LLM capability where the model can invoke external functions or APIs by generating structured calls, then use the results in its response.
tool permissioning: Restricting which tools or actions an agent is allowed to invoke, and under what conditions.
tool registry: A catalog of available tools an agent or platform can draw from, including their schemas and access permissions.
tool sandbox: An isolated execution environment where an agent's tool calls (like running code) happen safely without affecting production systems.
tool use: The general practice of an LLM invoking external tools, APIs, or code during a conversation to extend its capabilities beyond text generation.
tool-augmented LLM: A model that has access to external tools (search, code execution, calculators) to extend its capabilities beyond pure text generation.
tree of thoughts: A reasoning technique that lets a model explore and evaluate multiple branching reasoning paths before committing to an answer.
vector database: A database optimized for storing and searching high-dimensional embeddings by similarity, commonly used as the retrieval backend for RAG.
vibe coding: Building software by conversationally directing an AI coding agent and iterating on its output, with less manual code writing.
web search tool: A tool that lets an LLM query a live search engine and incorporate current results into its response.
workflow vs. agent: The distinction between a fixed, predefined sequence of LLM calls (workflow) and a system where the model dynamically decides its own steps (agent).
zero-shot prompting: Asking a model to perform a task with only an instruction and no examples included in the prompt.