All chapters
  1. Start hereSomething has to decide what runs next
  2. Foundations · 1Sequence, branch and loop: the three primitives of every workflow
  3. Foundations · 2State machines, DAGs, events and agent loops: four shapes of control
  4. Patterns · 3One agent with tools, or several specialized agents
  5. Patterns · 4Supervisor, planner-executor, router, swarm and peers: who talks to whom
  6. Patterns · 5Control plane and data plane: where code decides and where a model may
  7. Mechanics · 6Task queues, fan-out and fan-in, concurrency and rate limits
  8. Mechanics · 7Handoffs: what one agent must give the next
  9. Mechanics · 8Human approvals: pause, wait for a person, resume safely
  10. Production · 9Durable workflows: checkpoints, retries, compensation and cancellation
  11. Production · 10Permissions, budgets and termination: what a run may do, spend, and when it must stop
  12. Production · 11Failure propagation, circuit breakers and fallback routes
  13. Production · 12Trace propagation and outcome evaluation across a workflow
  14. Reference · 13Frameworks: LangGraph, Temporal, AutoGen, CrewAI and the provider SDKs
  15. Reference · 14Testing orchestration: transition coverage and fault injection
  16. Reference · 15Advanced: speculative execution, deadlocks, fairness and evaluating many agents
  17. Reference · 16The insurance lab: one quote workflow, end to end
  18. ReferenceGlossary
  19. AboutAbout this site and its sources
Reference

Glossary

Every term this site uses, each with what it is, what it is not, and how it shows up in the insurance quote workflow.

Every term this site uses, in one place. Each card opens the same drill-down as the underlined phrases in the text: one line, why it matters here, what it is, what it is not, and how it shows up in the quote workflow of the insurance example.

One sentence holds the subject together. Orchestration is the logic that decides what runs next, under which conditions, and how the pieces coordinate. Most of the words below name one way of making that decision, or one thing that can go wrong while it is made.

Agent loopThe loop inside an agent: call the model, run the tool it asked for, give back the result, repeat until it finishes or a limit stops it.AgentA program that calls a language model, runs the tool the model asks for, gives the result back, and repeats until the model answers or a limit stops it.Aggregation policyWhich branches are required, which optional, and what happens when one is missing or late.Approval tokenThe orchestrator issues it when the run suspends; the person's decision must carry it back.Attempt number1 for the first try of a step, 2 for the first retry, and so on. It starts at 1 for each step.AutoGenA framework for applications in which several agents talk in a team until a termination condition stops them; its repository is archived and names Microsoft Agent Framework as its successor.BackpressureWhen work arrives faster than it can be done, the busy part pushes back instead of letting the queue grow without limit.Bounded autonomyA model chooses freely inside limits that code sets and enforces, and its result is checked by code before it leaves the step.BranchThe second primitive: a condition decides which of several paths the run takes next.BudgetA limit on turns, tool calls, tokens or time, checked by code, that ends a loop or run when reached.CancellationAn outside request to stop the run; finished effects are compensated and the rest is skipped.CheckpointA saved copy of where the run stands: which steps succeeded, their outputs, and what comes next.Circuit breakerClosed: calls go through. Open: no calls, fallback at once. Half-open: one test call decides.CompensationWhen a run must stop, it reverses what a finished step did in the world, in business terms.Concurrency limitA cap on work in progress, protecting the workers and the dependency from too much at once.ConditionA yes-or-no test on the state of a run that decides whether a transition may be taken. On this site it is code.Context packageThe information the receiving agent gets, chosen so it can do its part and nothing else.Context windowThe limit on everything a model reads in one call: instructions, tool definitions, the input, and the conversation so far.Control planeThe part of a system that decides what runs, in what order, under which conditions, and when it stops; it holds the state those decisions depend on.Coordination costThe extra model calls, handoffs, waiting, and lost or repeated information that come from splitting work between agents instead of doing it in one.CrewAIA Python framework with two parts: crews, teams of role-based agents, and flows, event-driven workflows in which decorated methods start, listen and route.CycleA path through a graph of steps that returns to a step already passed. A DAG has none by definition.DAGA directed acyclic graph: steps as nodes, "must finish before" as one-way arrows, and no path that leads back to a step already passed.Data planeThe part of a system that does the work the control plane starts: tool calls, model calls, rule checks, writes.Dead-letter listA failed run is kept with its step and reason, so a person can look at it and act.DeadlockA waits for B and B waits for A, so neither can continue; no error is raised.Deterministic workflowA workflow in which code decides each next step from the run's recorded state, so the same state always leads to the same next step.Durable workflowThe run's state lives outside the process, so a new process can continue the run after a crash.Error boundaryA failure that reaches it travels no further; what lies beyond sees a status, not an exception.EscalationThe decision goes to a more senior role because the case requires it or because nobody answered in time.Event-drivenA way of writing control as reactions: when this event arrives, do that. What runs next depends on what arrives, and when.EventA record that something happened: a step finished, a person decided, a cancellation arrived. A transition is caused by an event.Evidence idAn id such as EV-ROOF-0412 that the lookup's span, the handoff package and the recommendation all carry.Failure propagationWhen one part fails, the failure travels up to what waited for it and sideways to what shares the same dependency.FairnessA written policy for which work runs next when the pool is full.Fallback routeWhen the normal path cannot be completed, the run takes a designed alternative instead of failing or guessing.Fan-inThe point where the parallel answers become one input for the next step.Fan-outWork that does not depend on each other is started together, so the step takes as long as the slowest piece.Fault injectionA test causes a specific failure at a chosen point to check how the orchestrator reacts.GuardA test, written in code, that must hold before the run may move on; here it sits at the exit of the step where a model chose, and checks the process that produced the result.Handoff contractThe written list of fields and guarantees every package for this handoff carries.HandoffOne agent stops working on the case and another starts, with a package of what it needs.Human approvalA step in a workflow where nothing more may happen until a person says yes, no, or something else.Human decisionA small record: who decided (a role), what, whether it went against the recommendation, and the reason.Idempotency keyThe caller sends the same key with every repeat of a write, and the receiver returns the first result instead of writing again.InvariantChecked over all cases and modes, not in one test: for example, no decision without a person.LangGraphA library in which you write the workflow as a graph of nodes and edges over a typed state; it runs the graph, saves a checkpoint at each step and can pause for a person.Least privilegeEach step or agent gets the smallest set of capabilities that lets it do its job, and nothing more.LivelockEvery action succeeds, yet the state that matters never changes.LoopThe third primitive: a step or a group of steps runs again, until a termination condition is true.Model choiceA decision about what to do next that a model makes during the run, instead of code written in advance.Multi-agent evaluationScore outcome, process, cost and behavior with one part down, over many runs; then find which agent caused each failure.Multi-agent systemA design in which several agents, each with its own instructions, tools and context, share a task and pass work between them.OrchestrationThe logic that decides what runs next, under which conditions, and how the pieces coordinate.OrchestratorThe program that runs a workflow: it holds the state of each run, starts each step, waits for it, and applies the conditions that choose the next one.Outcome evaluationDid the run end with the right route, recommendation, citations, missing list, approver role and status?OverrideThe underwriter decides the opposite of what was recommended, and says why.OwnershipAt every moment exactly one part is responsible: it finishes its part or says why not.Partial failureThe result is usable, and it states what is missing.Peer agentsAgents that pass the work to a fixed next neighbor by their own decision; control moves with the work and no party is central.PermissionA rule in the orchestrator that lists the tools a step may call; anything else is refused before it runs.PlanThe steps a run intends to take, written down as data before they run, so other parts can carry them out and code can check them.Planner-executorAn arrangement in which a planner (usually a model) writes the list of steps once and executors carry them out; the planner is called again only to replan.Policy fixtureUW-GUIDE: versions 2026.2 (current), 2025.4 (older) and this site's own 2026.3; rules R-ROOF-01 to R-HUMAN-01.Policy versionRecorded at the start of a run, stored in the recommendation, and checked again when the decision arrives.Provider SDKA library from a model provider that runs the loop of one agent (model call, tool call, repeat) and adds tools, limits, handoffs or subagents, and a way to pause for approval.Quote workflowThe site's running example: eight steps, three agents and one person, all synthetic.Rate limitFor example, at most 10 calls per second to a provider (illustrative), shared by every run that calls it.RecommendationThe output of the quote workflow: approve, decline, request_info or escalate, with reasons, the rule ids cited, anything missing, and the policy version.Replay testSame inputs, new code; any difference from the recording is a regression or an intended change, and a person decides which.ReplayThe engine records each step's result, and after a crash runs the workflow from the top, feeding it the recorded results instead of calling the steps.ResumeLoad the saved run, check the incoming event, and continue from the step after the wait.RetryThe orchestrator tries the step again because the failure might not happen twice.Return contractThe record the receiving agent returns when done, and what it returns when it cannot finish.RouterAn arrangement in which the input is classified once (by a model or by code) and a route table in code then decides every later handoff.Run idOne run of the quote workflow for one submission; a second run for the same submission gets a new one.RunOne execution of the quote workflow for one submission, with its own run_id and its own state.Runaway loopEach turn may succeed, yet the loop never reaches its end condition and keeps spending.SagaEither every step finishes, or the compensations of the finished steps run.SequenceThe first primitive: steps run one after another, and each starts only after the one before it has finished.Single agentOne agent, with one set of instructions, one running context and all the tools the task needs, that picks its own next step until it is done.SpanA name, a start, an end, a status, attributes, and a link to its parent span.Specialized agentAn agent whose instructions, tools and starting context are chosen for one job, and which sees nothing it does not need for that job.Speculative executionIf the work turns out to be needed, it is already done; if not, it is thrown away and its cost counted.Stale approvalThe decision was right for what the run saw, but something it depended on changed while the run waited.Stand-in agentIt returns fixed or seeded outputs for each input, without calling a model.StarvationThe system keeps running; some piece of work never gets its turn.State machineA way of writing down control as a table: the states something can be in, and for each state, which events move it where. Any move not in the table is refused.StateEverything the orchestrator has written down about one run: its status, the current step, the status and result of every step, and the event log.StepOne unit of work that the orchestrator starts, waits for, and records: a tool call, a model call, a rule check, or a wait for a person.SubmissionThe broker's quote request written down as one JSON record. Every step after intake reads this record, never the email.SupervisorA central agent whose model decides, at every step, which agent works next, and to which every agent returns its result.SuspendThe run saves everything needed to continue, marks itself as waiting, and lets the process forget it.SwarmAn arrangement with no central decider and no fixed order: the agent holding the work decides which agent gets it next, and may pick any of them.Task queueThe orchestrator puts pieces of work on it; a free worker takes the next one.TemporalA server plus language SDKs that record every step of a workflow in an event history, so a workflow continues after any crash and can wait for days.Termination conditionThe condition that, once true, ends a loop or a run. Every loop needs one that does not depend on the model.TerminationEvery loop and run ends for a recorded reason; the model finishing is one reason among several.TimeoutA limit on waiting for one call or step; after it, the orchestrator stops waiting and decides what next.ToolA named function, with a description, that the model may request; the program around the model runs it and returns the answer.TopologyHow several agents are arranged: who can hand work to whom, who decides which agent works next, and who sees the result.Trace id32 hex characters, created when the run starts, shared by every span of the run.Trace propagationThe trace id and current span id travel with the work, so the other side joins the same trace as a child.TraceThe connected record of everything a run did: steps, model calls, tool calls, waits, each as a span with a parent.Transition coverageFor every legal (state, event) pair, did at least one test make that transition happen?TransitionA move of a run from one state to another, caused by an event such as a step finishing, and allowed by a condition.Turn limitThe simplest budget: the loop may call the model at most this many times.Underwriter cockpitWhere the stored recommendation appears and where the person's decision is sent back from, with the approval token.UnderwriterThe person at the insurer who decides whether to accept a risk. In the quote workflow, the only party allowed to decide.WorkerA thread, process or container that takes an item from the queue, runs it, and takes the next.Workflow engineSoftware that runs a workflow you defined and keeps its state outside your process, so a run survives crashes, retries failed steps and can wait for an outside event.WorkflowThe written-down definition: the steps, and the rules for which step follows which.

Each term is explained in full on one page and used everywhere else. Four identifiers appear on many cards and are easy to mix up: submission_id names the business record, run_id names one execution of the workflow for it, attempt_number counts the tries of one step inside a run, and trace_id names the record of what the run did. The page on tracing keeps them apart. Where the ideas come from, and which of them this site proposes as its own design, is on About.