Glossary

Reference intermediate

A working vocabulary for building multi-agent systems. Terms borrow from distributed systems — deliberately, because a fleet of agents is a distributed system whose nodes happen to be non-deterministic. See the course landing page and siblings: rules, cheat-sheet, framework-reference, troubleshooting.

A–C

Term Definition
Agent An LLM-driven unit with its own instructions, tool set, and (usually) its own context window. The atomic node of an orchestrated system.
Backpressure A signal from a saturated downstream agent or queue that throttles upstream producers to prevent unbounded queue growth.
Blackboard A shared workspace (often a key-value store or document) that agents read from and write to instead of messaging each other directly — a form of shared state coordination.
Circuit breaker A guard that trips after repeated failures from a downstream agent or model, short-circuiting calls so they fail fast instead of piling up retries.
Compensation A corrective action that undoes the visible effect of a completed step when a later step fails — the rollback unit of a saga.

D–E

Term Definition
Dead-letter queue (DLQ) A holding queue for messages or sub-tasks that failed all retries, parked for later inspection or manual replay rather than silently dropped.
Decomposition Splitting a complex goal into sub-tasks small enough for individual agents — by skill (functional), by partition (data), or by phase (temporal).
Distributed tracing Correlating one logical request across many agents and tool calls via a shared trace ID, reconstructing the full causal path.
Eventual consistency The acceptance that shared state read by different agents may briefly disagree, converging once all writes propagate — common with blackboard coordination.
Event-driven A coordination style where agents react to events published on a bus rather than being called directly, decoupling producers from consumers.

F–H

Term Definition
Fan-out / fan-in Dispatching one task to many agents in parallel (fan-out) then aggregating their results into a single answer (fan-in); the core of pipeline parallelism.
Fallback A degraded path taken when the primary agent fails — a cheaper model, a simpler heuristic, or a cached prior result.
Guardrail A validation layer at the orchestration boundary that inspects an agent's input or output and blocks, edits, or escalates unsafe results.
Handoff An explicit transfer of control (and relevant context) from one agent to another, e.g. a triage agent handing a coding task to a specialist.
Hierarchical pattern Multiple layers of supervisors, each managing a team of workers — a supervisor of supervisors, used when one coordinator cannot fan out far enough. 
from claude_agent_sdk import AgentDefinition, ClaudeAgentOptions, query

# Workers and coordinator are all AgentDefinitions; the coordinator delegates
# via the built-in `Agent` tool (the Agent SDK has no separate handoff() call).
AGENTS = {
    "researcher": AgentDefinition(
        description="Gathers primary sources.",
        prompt="Search the web and return url/claim pairs.",
        tools=["WebSearch", "WebFetch"]),
    "writer": AgentDefinition(
        description="Drafts prose from gathered sources.",
        prompt="Draft from the sources; add no facts of your own.",
        tools=["Read"]),
}

opts = ClaudeAgentOptions(
    system_prompt="Research first, then delegate drafting to the writer.",
    allowed_tools=["Agent"],          # the coordinator's only tool: delegate
    agents=AGENTS, permission_mode="default")

async for message in query(prompt="Brief me on local LLM trends.", options=opts):
    ...

I–M

Term Definition
Idempotency The property that re-running a step (after a retry or replay) produces the same effect as running it once — essential because retries are routine.
Idempotency key A caller-supplied unique token attached to a request so the receiver can detect and dedupe a replayed call.
Intelligent routing Sending each task to the cheapest model or agent capable of handling it, escalating to stronger models only when complexity demands.
Message passing Coordination via structured, schema-defined messages exchanged between agents — explicit, auditable, and easy to version.
Multi-agent system (MAS) Any system where two or more agents cooperate (or compete) to accomplish a goal that exceeds a single agent's capacity.

O–P

Term Definition
Orchestration The discipline of coordinating multiple agents — deciding who does what, in what order, with what data, and how failures are handled.
Peer-to-peer pattern Agents communicate directly with one another without a central coordinator; flexible but harder to reason about and debug.
Pipeline pattern Agents arranged as sequential stages, each transforming the output of the previous one — extraction, then validation, then summarization.
Prompt caching Reusing the expensive prefix of a prompt (system instructions, shared context) across agent calls so it is processed once, cutting latency and cost.
Provenance A record of which agent produced which artifact and from what inputs — the audit trail that makes results trustworthy and reproducible.

R–S

Term Definition
Retry budget A cap on total retries across the system (not just per call) so a storm of failures cannot multiply token spend without bound.
Saga A long-running workflow modeled as a sequence of steps, each with a compensating action, giving rollback semantics without distributed transactions.
Shared state A common store all agents read and write — the blackboard model; powerful but introduces concurrency and consistency concerns.
SLO (Service Level Objective) A measurable reliability target for an agent system, e.g. "95% of research runs complete in under 90 seconds with a valid answer."
Supervisor A central coordinator agent that decomposes a goal, delegates sub-tasks to specialist workers, and assembles their outputs.

T–W

Term Definition
Temporal / Prefect / Airflow Workflow engines that manage deterministic flow control, retries, and durable state while AI agents handle the intelligent steps inside activities or tasks.
Token budgeting Allocating a ceiling of tokens per agent or per task so no single branch of the workflow can consume the entire spend.
Tool A callable (API, function, query) an agent may invoke; least-privilege scoping of tools per agent is a core security control.
Workflow activity A unit of work in a workflow engine (Temporal's activity, Prefect's task) — the place to wrap a non-deterministic agent call with timeouts and retries. 
# Temporal: wrap an agent call as a durable, retryable activity.
from temporalio import activity, workflow
from datetime import timedelta

@activity.defn
async def run_synthesis(sources: list[str]) -> str:
    return await synthesis_agent.run(sources)

@workflow.defn
class ResearchWorkflow:
    @workflow.run
    async def run(self, sources: list[str]) -> str:
        return await workflow.execute_activity(
            run_synthesis, sources,
            start_to_close_timeout=timedelta(minutes=3),
        )

See Also