Agentic Vocabulary — The Language of AI Agents
Why a Vocabulary Section?
"AI agents" is one of the most overloaded terms in the field. The same word describes a simple LLM call with one tool, a 15-node workflow, a ReAct loop, and a multi-agent system with specialized subagents. When engineering, product, and leadership mean different things by "agent," decisions get made on misaligned assumptions.
This page defines the terms. Use it as shared reference.
Core Terms
Agent: An LLM that can take actions — not just generate text, but call tools, read files, execute code, or trigger APIs — and iterate based on results. The defining property is a loop: observe → think → act → observe again.
Tool (Function): An external capability the model can invoke. Examples: web search, code execution, database query, API call, file read/write. Tools are defined as schemas (name, description, parameters) and passed to the model. The model decides when and how to call them; your code executes them and returns results.
Tool Call (Function Call): A structured output from the model saying "run this tool with these parameters." Not the execution — the execution happens in your code, outside the model.
Agent Loop: The iterative cycle: prompt the model → model returns either a tool call or a final answer → if tool call, execute it and feed results back → repeat until final answer.
Orchestrator: The code or model that coordinates an agent or multi-agent system. Decides which agents to invoke, passes context, and aggregates results.
Subagent: A model invocation called by an orchestrator to handle a specific sub-task. May have its own tools, context, and termination criteria.
Handoff: When one agent transfers control and context to another agent for a specialized task. The handoff includes the context the next agent needs.
Memory Types
In-context memory: Everything in the current context window. Ephemeral — gone when the conversation ends. Fastest and most reliable memory; limited by context window size.
External memory (vector store, database): Information stored outside the model and retrieved at query time. Persistent across conversations. Requires a retrieval step (see RAG). Scales to large corpora but introduces retrieval latency and precision errors.
Fine-tuned weights: Knowledge baked into the model's parameters through training. Permanent until retrained. Cannot be updated without retraining or fine-tuning. Best for stable behavioral patterns, not current facts.
Planning Vocabulary
ReAct (Reasoning + Acting): An agent pattern alternating between reasoning steps (thinking through the problem) and action steps (calling tools). The reasoning is visible in output, which helps debugging.
Plan-and-Execute: The model first creates a full plan, then executes each step. More predictable than ReAct; less adaptive if intermediate results change the situation.
Reflection: An agent step where the model reviews its own prior outputs, checks for errors, and decides whether to revise. Significantly improves output quality at the cost of extra token usage.
Self-critique: A specific form of reflection focused on identifying flaws before finalizing output.
Multi-Agent Vocabulary
Supervisor pattern: A supervisor agent breaks a task into sub-tasks, routes each to a specialized worker agent, and synthesizes the results.
Peer pattern: Multiple agents run in parallel on the same problem; their outputs are compared or aggregated.
Context passing: The mechanism by which one agent's output becomes another agent's input. Context passing design is one of the most important engineering decisions in a multi-agent system.
When Agents Are and Aren't Appropriate
Agents are appropriate when:
- The task requires multiple steps with dependencies between them
- The right next step depends on results of the prior step (dynamic branching)
- External data or actions are required as part of the task
Avoid agents when:
- A single well-designed prompt can accomplish the task
- The steps are always the same (use a pipeline or chain instead)
- The task is latency-sensitive (every loop adds round-trips)
Before building an agent, ask: can this be a good prompt? A well-designed multi-shot prompt that handles the task deterministically is more reliable, cheaper, and faster than an agent loop. Use agents when the task genuinely requires dynamic iteration — not as the default architecture.
Further Reading
- Agents and Tool Use — the practical architecture behind agent systems
- RAG — the most common pattern for giving agents access to knowledge