Multi-agent framework glossary
Reviewed Nov 2026
Agent as tool
Agent as tool is a pattern where one agent is wrapped so another agent can call it like any other tool. In the OpenAI Agents SDK, a manager agent keeps control of the conversation and calls specialist agents through Agent.as_tool(). The SDK suggests this when a specialist should help with a bounded subtask without taking over the user-facing conversation. Google ADK lists Agents-as-Tools among its tool types, where another, potentially specialized, agent serves as a tool for a parent agent.
Agent network
Agent network describes a setup where a routing agent uses a language model to pick which subagents, workflows or tools handle a request. In Mastra, a routing agent uses an LLM to interpret a request and decide which primitives to call, in what order, and with what data. Mastra's docs mark agent networks as deprecated, to be removed in a future major release, and say to replace them with supervisor agents. Check that page before starting new work, and see Mastra vs LangGraph.
AI Agent node
AI Agent node is the n8n workflow node that runs an agent built from a chat model and connected tools. The node lets you build an AI agent in n8n, where you connect a chat model and one or more tools and the agent decides which tools to call to complete a task. You must connect at least one tool sub-node. The agent type setting is deprecated from n8n 1.82.0, and all AI Agent nodes now work as a Tools Agent. For n8n beside LangGraph, see n8n vs LangGraph.
Callback
Callback is a function you register with an agent that the framework calls at set points in a run, so you can observe or change what happens. Google ADK docs describe callbacks as standard functions that you define and associate with an agent when you create it. ADK's Before Model and After Model callbacks inspect or modify the data going to and coming from the LLM, while Before Tool and After Tool callbacks give control points specifically around the execution of tools.
Checkpointer
Checkpointer is a component that saves a graph's state while it runs, so work can pause and resume later. It comes up when a workflow needs human review or recovery after a failure. In LangGraph, a checkpointer saves a snapshot of graph state at each super-step, organized into threads. The persistence docs say MemorySaver and InMemorySaver store checkpoints in RAM, so all checkpoints are lost when the process restarts.
Command
Command is an object a node returns to apply a state update and choose where the graph goes in one step. You reach for it when a step must record a result and route at the same time. The Graph API overview says Command updates state while routing to the next node, including resume after an interrupt. The build checklist adds that most graphs only need nodes, edges and conditional edges, and advises keeping routing in edges otherwise.
Conditional edge
Conditional edge is a connection whose target node is chosen at run time from the current state instead of being fixed in advance. It is how a graph branches or loops back. LangGraph's Graph API overview describes edges as fixed or conditional transitions that determine the next node. Its build checklist lists branching as a control-flow choice in which conditional edges pick the next node from state.
Crew
Crew is the CrewAI object that groups agents with the tasks they are meant to complete. You define one when you assemble a team of agents for a job. CrewAI's Crews docs say a crew represents a collaborative group of agents working together to achieve a set of tasks. Its process attribute sets the process flow the crew follows, and the default is sequential.
Executor
Executor is a processing unit in a workflow graph that receives a message, does some work and passes output on. Microsoft Agent Framework docs call executors the fundamental building blocks that process messages in a workflow, and say they receive typed messages and can produce output messages or events. Executors can be custom logic components or AI agents that use LLMs to generate responses. In .NET, the WorkflowBuilder API connects typed executors through edges and conditions.
Flows
Flows are CrewAI workflows that chain crews and tasks into multi-step processes, where one method can listen for another task's output and run once it arrives. CrewAI's Flows docs say Flows allow you to create structured, event-driven workflows, and that they let developers combine and coordinate coding tasks and Crews. The @start() decorator marks entry points for a flow, and a method decorated with @listen() runs when the specified task emits an output.
Function tool
Function tool is an ordinary function a developer writes and exposes to an agent, with its signature turned into a schema the model can read. OpenAI's Agents SDK says you can use any Python function as a tool, with the tool name taken from the function name and the description from its docstring, unless you provide either. In Google ADK, assigning a function to an agent's tools list makes the framework wrap it as a FunctionTool.
Guardrail
Guardrail is a check on what goes into or comes out of an agent that can stop the run when the check fails. OpenAI Agents SDK docs say that input guardrails run on the initial user input, and output guardrails run on the final agent output. Input guardrails default to parallel execution, running concurrently with the agent, so if a tripwire fires, the agent may have already consumed tokens and executed tools before being cancelled.
Hierarchical process
Hierarchical process is a way of running a crew in which a manager agent hands tasks to other agents instead of each task being assigned in advance. You choose it when assignment should be decided during the run. CrewAI's Processes docs say a manager language model or a custom manager agent must be specified in the crew to enable it. They also say the manager allocates tasks to agents based on their capabilities, reviews outputs, and assesses task completion.
Kickoff
Kickoff is the call that starts a crew running its tasks. In CrewAI, kickoff() starts the execution process according to the defined process flow, and kickoff_for_each() executes tasks sequentially for each provided input event or item in the collection. For async code, CrewAI documents akickoff() as native async and kickoff_async() as a thread-based wrapper around synchronous execution. For high-concurrency workloads, akickoff() is recommended because it uses native async for task execution, memory operations and knowledge retrieval.
LlmAgent
LlmAgent is an agent class whose next step is chosen by a language model rather than by fixed code. In Google ADK, the class is often aliased simply as Agent and is described as a core component of the framework, acting as the core part of an agent application. The AI model dynamically decides how to proceed, which tools to use, if any, and what output to provide. As a result, the docs say its behavior is non-deterministic and must be built and evaluated with that in mind.
LoopAgent
LoopAgent is a workflow agent that reruns its sub-agents in order, round after round, for work such as revising a draft until it is good enough. Google ADK docs say it executes its sub-agents in a loop for a specified number of iterations or until a termination condition is met. They warn that the LoopAgent itself does not inherently decide when to stop, so you must implement a termination mechanism. A sub-agent can signal termination by emitting an event that sets escalate to true, and the built-in exit_loop tool sets that flag.
ParallelAgent
ParallelAgent is an agent type that starts its sub-agents at the same time instead of in sequence, which suits tasks that do not depend on each other. Google ADK docs state that the class executes its sub-agents concurrently. Each sub-agent works in its own execution branch, with no automatic sharing of conversation history between branches during execution. Even so, session state is shared, and all branches run against the same session.
ReAct agent
ReAct agent names an agent that alternates between reasoning about a task and calling tools, feeding each tool result into its next step until it can answer. Frameworks name and package this loop in different ways, so read each framework's docs for what actually runs. In n8n's documentation, the root node list shows a ReAct Agent entry marked Deprecated, and the same page says all AI Agent nodes now run as a Tools Agent.
Reducer
Reducer is a function that merges a new update into the value already stored for a state key. It matters when more than one node writes the same key. LangGraph's overview says reducers control how node updates merge into state, with one reducer per key, and that updates overwrite the previous value when no reducer is set. It describes a reducer as a binary function that takes the current value and the node's update.
RunContext
RunContext is the object passed into tools and instruction functions so they can read the current run's dependencies and state. In Pydantic AI, dependencies are accessed through the RunContext type, which should be the first parameter of instructions functions. RunContext also provides access to the running agent via .agent. Agno uses the same name: a run_context: RunContext parameter gives a tool the current user, session state, dependencies, metadata or knowledge filters.
Runner
Runner is the object that executes an agent on an input and returns the result. In the OpenAI Agents SDK, you can run agents via the Runner class through three methods. The runner then runs a loop that calls the model for the current agent, and the loop ends once that output is classified as final. Going past the max_turns limit raises a MaxTurnsExceeded exception. In Google ADK, an error is raised when a runner attempts to access or execute a session that does not exist.
Send API
Send API is the LangGraph mechanism for fanning work out so that one node runs once per item, each run with its own input. You use it for map-reduce or orchestrator-worker patterns. LangGraph's overview says Send dynamically invokes nodes for fan-out. The build checklist says to use Send when the item count is only known at runtime and every run of the node needs its own input.
SequentialAgent
SequentialAgent is a workflow agent that runs its sub-agents one after another in a fixed order, so a pipeline always follows the same steps. Google ADK defines it as a template workflow agent that executes its sub-agents in the order they are specified in a list, and its execution is not controlled by an AI model. The same page marks template workflows as deprecated, saying that in ADK Python, TypeScript, Go, and Kotlin they have been superseded by more flexible workflow structures, including graph-based and dynamic workflows.
Session
Session is the stored record of one conversation thread, holding its history and working data so an agent keeps context between turns. Google ADK docs say that a Session represents a single conversation thread between a user and your agent. OpenAI's Agents SDK describes sessions as storing conversation history, allowing agents to maintain context without explicit manual memory management.
StateGraph
StateGraph is the LangGraph builder class for a graph whose nodes share one state object. The Graph API overview calls StateGraph the main graph builder, which you parameterize with your state schema. The library source describes it as a graph whose nodes communicate by reading and writing to a shared state. The overview also says you must compile the graph before you invoke or stream it.
Structured output
Structured output is a model response shaped by a typed schema, so your code receives fields it can check instead of free text. In the OpenAI Agents SDK, passing an output_type tells the model to use structured outputs instead of regular plain text responses. In Pydantic AI, where it is still up to the model to abide by the schema, the framework will validate the returned structured data and tell the model to try again if validation fails, though its docs warn this may not be sufficient for a model that is not intelligent enough.
Sub-workflow
Sub-workflow means a workflow called by another workflow, so shared logic lives in one place. n8n's glossary defines it as a workflow that another workflow calls and says to use sub-workflows to split a large workflow into smaller, reusable parts. In n8n, creating one uses the Execute Workflow and Execute Sub-workflow Trigger nodes. n8n also states that sub-workflow executions don't count towards your plan's monthly execution or active workflow limits.
Subgraph
Subgraph is a graph that runs as one node inside a larger graph. It lets you split a big workflow into parts you can build and reuse separately. LangGraph's subgraph guide says a subgraph is a graph used as a node in another graph, and lists building multi-agent systems among its uses. The guide also says different teams can work on different parts of the graph, as long as the subgraph's input and output schemas are respected.
Task
Task is a unit of work with a description and an expected result, carried out by an agent. You write tasks and pass them to a crew. CrewAI's Tasks docs define a task as a specific assignment completed by an agent. They say each task must include a description and an expected_output, while the agent attribute, the agent responsible for executing the task, is optional.
Team
Team means a group of agents, led by a coordinating agent, that works on one task. Agno's docs say a Team coordinates agents or nested teams, and in the default coordinate mode the leader can delegate tasks based on member roles and synthesize their results. Agno lets you select coordinate, route, broadcast, or tasks mode. In Agno, leader and members make separate calls, which adds latency, token usage and coordination state. For a team-style framework next to a crew-style one, see Agno vs CrewAI.
Toolkit
Toolkit is the name for a bundle of related tools that you hand to an agent as one unit. In Agno, you can add a Python function or toolkit to tools, and the model can select it when a request requires it. Agno's tool guide points to a toolkit when you want to add a packaged integration with related operations. You can limit operations exposed by a toolkit with include_tools and exclude_tools.
Toolset
Toolset names a reusable collection of tools registered with an agent in one step. Pydantic AI defines a toolset as a collection of tools that can be registered with an agent in one go, reused by different agents, and swapped out at runtime or during testing. For MCP, Pydantic AI provides MCPToolset for connecting to and calling tools on local and remote MCP servers, with the MCP capability as the recommended higher-level entry point. Treat toolset and toolkit as framework-specific names, and use the one your framework's docs use.
Trigger node
Trigger node refers to the node that starts a workflow run when its condition is met; n8n's glossary calls it a special node responsible for executing the workflow in response to certain conditions and says every production workflow needs at least one trigger to determine when it should run. The Execute Sub-workflow Trigger node is used to start a workflow in response to another workflow, and n8n's page says to place it first in that workflow.
Tripwire
Tripwire is the signal a guardrail check raises when an input or output fails it, so the run can stop. You meet it when you add guardrails to an agent. In the OpenAI Agents SDK, a failed guardrail can signal a tripwire, and the runner then raises an exception and halts agent execution. When an input guardrail runs concurrently with the agent, the docs warn that the agent may have already consumed tokens and executed tools before being cancelled.
Working memory
Working memory is a store of key details an agent keeps available about a user or task across interactions. Mastra calls it the agent's active scratchpad, able to retain a person's name, preferences or other important details. In Mastra, resource-scoped memory is the default and persists across all conversation threads for the same user, while thread-scoped memory is isolated per conversation thread. Switching between scopes means the agent won't see memory from the other scope. Decide early which scope your application needs.
Where do these facts come from?
Reviewed Nov 2026
- Graph API overview (docs.langchain.com)
- langchain-ai/langgraph: libs/langgraph/langgraph/graph/state.py (GitHub)
- Guardrails (openai.github.io)
- Build checklist for the Graph API (docs.langchain.com)
- Checkpointers (docs.langchain.com)
- Persistence (docs.langchain.com)
- Subgraphs (docs.langchain.com)
- Crews (docs.crewai.com)
- Tasks (docs.crewai.com)
- Processes (docs.crewai.com)
- Flows (docs.crewai.com)
- Simple agents (adk.dev)
- Sequential workflow (adk.dev)
- Parallel workflow (adk.dev)
- Loop workflow (adk.dev)
- Running agents (openai.github.io)
- Session: Tracking individual conversations (adk.dev)
- Overview (openai.github.io)
- Callbacks: Observe, Customize, and Control Agent Behavior (adk.dev)
- Agent orchestration (openai.github.io)
- Custom Tools for ADK (adk.dev)
- Tools (openai.github.io)
- Overview (adk.dev)
- Microsoft Agent Framework Workflows (learn.microsoft.com)
- Workflow concepts (learn.microsoft.com)
- What are Teams? (docs.agno.com)
- What are Tools? (docs.agno.com)
- Agent networks (mastra.ai)
- Working memory (mastra.ai)
- Dependencies (pydantic.dev)
- Agents (openai.github.io)
- Output (pydantic.dev)
- Toolsets (pydantic.dev)
- AI Agent (docs.n8n.io)
- Key concept glossary (docs.n8n.io)
- Break workflows into smaller parts (docs.n8n.io)
- Execute Sub-workflow Trigger (docs.n8n.io)
- Kickoff Crew Asynchronously (docs.crewai.com)