Three designs come back for the same job. Whatever framework each one uses, they differ in who decides the next step: your code, one model, or several models coordinating. The job is an IT service desk's overnight queue: about a thousand tickets, each to be classified, checked against the user's account and device records, and answered by morning with a draft reply that a person approves. The first design is a fixed workflow: two model calls per ticket, with code doing the lookups. The second is a single agent that decides which systems to query. The third is a lead agent that briefs three specialist agents, for identity, network and hardware.
All three can produce a reply. They send very different bills. To show how different, here is a deliberately simplified model of one night: it counts the tokens each design sends per ticket, prices them at one published rate, and then states each bill as a multiple of the workflow's. The multiple is the column to read, because it barely depends on whose rate you use. The assumptions are printed underneath.
| Design | Input tokens per ticket | Bill for 1,000 tickets | Multiple of the workflow | What bounds the bill |
|---|---|---|---|---|
| Fixed workflow | 4,500 | $12.20 | 1 | Its steps and your input limits |
| Single agent, 3 to 12 turns | 16,950 to 156,900 | $39.90 to $333.30 | 3.3 to 27.3 | Only its cap |
| Lead plus three workers, 2 to 8 turns each | 35,750 to 232,400 | $97.00 to $517.30 | 8.0 to 42.4 | Only its caps |
The model's assumptions:
- Prices: one frontier model's published rate, used only as the input: Claude Sonnet 5.5 at $2 per million input tokens and $10 per million output tokens on its pricing page on 12 November 2026. No batch discount; tool calls cost nothing. At any input-to-output price ratio from 1:3 to 1:8, the multiples stay within about 3 to 30 times (agent) and 8 to 45 times (three workers).
- The workflow sends 4,500 tokens and gets 320 back per ticket.
- A turn is one model call, so N turns means N−1 tool calls and a final turn that writes the reply.
- Each agent turn adds a 150-token tool call and a 1,500-token tool result to a 4,000-token starting context, and the whole history is resent each turn (the API is stateless). The final turn writes a 300-token reply.
- In the third design, the lead agent plans (4,000 tokens in, 300 out), each worker starts from 3,500 tokens and returns a 500-token summary, and the lead then drafts the reply from the summaries (5,800 in, 300 out).
- With prompt caching at the same page's rates ($2.50 per million for 5-minute cache writes, $0.10 for hits), within each ticket's loop: the agent costs about $25 to $88 (2.1 to 7.2 times the uncached workflow), the three workers about $85 to $203 (6.9 to 16.6 times).
The model says nothing about quality: a workflow that cannot handle the hard ticket is cheap and wrong. It also prices caching only roughly and leaves out batching, retries and tool costs, so run it with your own token counts before you quote anyone a number. What it does show is the shape. Without caching, quadrupling the turns, from 3 to 12, multiplies the agent's bill by more than eight, because each turn re-reads everything before it; with caching, by about 3.5. Either way, the difference that matters is quote versus range. A workflow is bounded by its steps and the input limits you set, so its bill is a quote before the run. An agent is bounded only by its cap, and a cap turns cost risk into an unfinished ticket: decide where a capped run goes, such as a person's queue (loop engineering covers the escalation). The workflow keeps two savings the agents mostly lose: its static prompt can be cached across tickets, and batch processing suits it best, "reducing costs by 50 percent" for work that can wait; an agent waits one batch per turn, so only short loops fit the night.
Give the model only as much of the control flow as the task needs, and move up a level only on evidence.
Who owns the next step decides the shape, and five questions, asked in order, settle it for a given job. Multi-agent earns its place only with a real boundary or real breadth, and even then with one writer; most designs end as hybrids, often a bounded agent inside a workflow.
Workflow, agent and multi-agent, defined by control flow
Frameworks and vendors name these shapes in different ways. One lens covers all three here, because it is the one an architecture review can check: who owns the next step?
- Workflow: code chooses. A model may work inside a step, classifying, extracting or drafting, but code lists the branches, and the model never decides whether the run continues. If a model produces a label, code routes on it.
- Agent: the model chooses, inside limits that code enforces. Code decides which tools exist, how many turns are allowed, how much the run may spend and which actions need a person.
- Multi-agent: several model-led loops choose, each with its own context. On top of that sits the coordination: who delegates, who merges the results and who writes.
The major providers and frameworks draw the same line. LangGraph's workflows and agents page says workflows "have predetermined code paths", while agents "define their own processes and tool usage". OpenAI's Agents SDK orchestration guide offers two ways to decide what runs next: "allowing the LLM to make decisions", or "determining the flow of agents via your code". Anthropic's Building effective agents describes workflows as "orchestrated through predefined code paths" and agents as systems that "dynamically direct their own processes and tool usage".
The name on the box does not tell you the shape. Google's Agent Development Kit (ADK) called its fixed sequencers "workflow agents"; its template workflows page says they run "without consulting an AI model for assistance with the orchestration", and marks them superseded by graph-based and dynamic workflows. n8n calls everything a workflow, including one whose AI Agent node works so that "the agent decides which tools to call".
Five questions that choose the shape
Ask these in order and stop at the first answer that settles the shape. On the overnight queue, most tickets stop at the first.
1. Can you write the steps down before the run starts?
If you can, build a workflow. Most of the queue fits: password resets, access requests, a printer that will not print. Classify, look up, draft, approve. Anthropic recommends a fixed chain when "the task can be easily and cleanly decomposed into fixed subtasks". Routing fits too: a model labels the ticket and code routes on the label. Our note on graph engineering sets out the edge-level rules for that design.
The warning sign is a rulebook that keeps growing. OpenAI's practical guide to building agents names "difficult-to-maintain rules" as one place where an agent may serve better: "Systems that have become unwieldy due to extensive and intricate rulesets". When branches start encoding judgement, make the judging step an agent, not the whole workflow.
2. Does the path depend on what the model finds?
"My VPN stopped working yesterday" has no fixed path. The fix might sit in the account, in the device certificate or in last night's network change, and each answer decides the next check. That is agent territory, but first apply the test Microsoft's Agent Framework overview puts first: "If you can write a function to handle the task, do that instead of using an AI agent." Anthropic describes agents as suited to "open-ended problems where it's difficult or impossible to predict the required number of steps, and where you can't hardcode a fixed path". It also warns: "The autonomous nature of agents means higher costs, and the potential for compounding errors."
So the agent gets limits in code: a short tool list, a turn cap, a spend cap, and approval before anything changes an account. Microsoft's AI agent orchestration patterns call a single agent with tools "Often the right default for enterprise use cases" and add: "To guard against infinite tool-call loops, set iteration limits." A limit only holds if your code does the counting; loop engineering covers how, along with what starts and stops a run. Inside the agent, harness engineering decides what the model can touch and context engineering what it reads.
3. Do the parts need separate context, permissions or owners?
Only here does multi-agent enter. Microsoft's Cloud Adoption Framework, in Single agent or multiple agents, names "Crossing security and compliance boundaries" and "Multiple teams involved" as reasons, and notes the single agent's trade-off: "Broad functionality requirements complicate least-privilege security because single agents need permissions for all potential actions."
The other reason is breadth: work that splits into independent, mostly read-only parts that together exceed one context window. On the service desk, an agent that must never see HR records while another reads them is a boundary, and code, not the lead, decides what each summary may carry. "We have three specialist teams" on its own is not.
Nor does a boundary always call for another agent. Scoped tools with separate credentials, or a workflow that hands one step to another team's service, can draw the same line with less coordination. Choose the simplest design that enforces the boundary.
4. Do you need a quote before the run, or is a cap enough?
The opening table answers this for the queue. Some processes need a quote on cost and time: a fixed cost per ticket, a price a customer sees before starting, a nightly batch that must finish by 7 a.m. Others can live with a range and a hard cap. Time is part of the quote: an agent's turns run one after another, and a thousand tickets of them must fit inside the night and your provider's rate limits. Google Cloud's guide to choosing an agentic design pattern asks it directly: "Can you support patterns that require multiple calls to the model for a single request?" FinOps for AI agents covers pricing the completed task, not the token.
5. How will you check the output?
Code, a person and a model can each check output, and they are not equal. Code checks are cheap and repeatable: the reply quotes the right ticket number and links only to approved help articles. A person checks what cannot be undone; our note on autonomy tiers covers where. A model checking a model is the weakest unless the checker is independent: Cognition, below, reports its reviewer agent works best when the coding and review agents "do not share any context beforehand". Prefer a check the producing model cannot influence.
What each step up costs, with the evidence
The published evidence is young, and much of it comes from vendors describing their own systems, as Anthropic and Cognition do below; Google Research's study and the Cemri failure analysis, both below, used benchmarks and older models. Each number stays with the system it was measured on: treat it as a signal about a system like that one, and measure yours.
Tokens and money
Every step up multiplies the tokens, so the value of the task has to carry the bill. One published set of multiples comes from How we built our multi-agent research system, which reports from Anthropic's own product data that "agents typically use about 4× more tokens than chat interactions, and multi-agent systems use about 15× more tokens than chats". The conclusion applies more widely: "For economic viability, multi-agent systems require tasks where the value of the task is high enough to pay for the increased performance."
When multi-agent pays
Multi-agent pays when the work is broad, parallel and mostly reading, and part of what it buys is simply more reading.
Google Research's Towards a science of scaling agent systems tested 180 agent configurations. On a parallelisable financial-reasoning task, centralised coordination "improved performance by 80.9% over a single agent". On sequential planning, "every multi-agent variant we tested degraded performance by 39-70%". Error handling mattered as much: agents working in parallel without talking "amplified errors by 17.2x", while an orchestrator held that to 4.4 times.
Cognition, which argued against multi-agent designs in 2025, reported in 2026 in Multi-Agents: What's Actually Working that it now runs some in production. Its summary: "multi-agent systems work best today when writes stay single-threaded and the additional agents contribute intelligence rather than actions." Its examples include a reviewer agent with a clean context that checks a coding agent's work. A company narrowing its own advice ten months later is a reminder that the right shape moves with the models: a workflow that a weaker model needed can constrain a stronger one, so revisit the decision when you change models.
Anthropic's research post gives the most detailed published case. On Anthropic's internal research evaluation, a lead agent on Claude Opus 4 with Claude Sonnet 4 subagents "outperformed single-agent Claude Opus 4 by 90.2%", on "breadth-first queries that involve pursuing multiple independent directions simultaneously". The post is candid about why: on the BrowseComp benchmark "token usage by itself explains 80% of the variance". Part of the gain is buying more reading. Parallel subagents also "cut research time by up to 90% for complex queries" in Anthropic's system.
When multi-agent does not pay
When the parts depend on each other, or several agents write, coordination costs more than it returns. Cognition's original post, Don't Build Multi-Agents, named the failure: "Actions carry implicit decisions, and conflicting decisions carry bad results." Two agents writing in parallel make choices the other cannot see. Anthropic draws the same boundary from the other side: "domains that require all agents to share the same context or involve many dependencies between agents are not a good fit for multi-agent systems today", and "most coding tasks involve fewer truly parallelizable tasks than research".
A large failure analysis, and by its authors' description the first failure taxonomy for multi-agent systems (MAST), is Why Do Multi-Agent LLM Systems Fail? by Cemri and colleagues, presented at NeurIPS 2025. It annotated more than 1,600 traces across seven frameworks and found 14 failure modes in three categories: system design issues, inter-agent misalignment and task verification. Failure rates on seven open-source systems ranged from 41% to 86.7%, on different benchmarks, so not directly comparable. For an architect, two findings matter: failures "often stem from system design issues, not just LLM limitations", and "many existing verifiers perform only superficial checks".
Attack surface
Autonomy you do not need is risk you do not need. In a workflow, ticket text can change a label; in an agent it can choose the next tool call. Every extra agent is another place to inject instructions and another channel to secure. The OWASP Top 10 for Agentic Applications 2026 lists Insecure Inter-Agent Communication and Cascading Failures as risks of their own. Its principle of Least-Agency puts this whole argument in security terms: "deploying agentic behavior where it is not needed expands the attack surface without adding value."
What the providers advise
Begin at the lowest level that does the job, and climb only on evidence. The five major providers' guidance says the same, from AWS ("Begin with targeted single-agent solutions") and Anthropic ("finding the simplest solution possible") to Google Cloud ("start with a single agent"), Microsoft ("Use the lowest level of complexity that reliably meets your requirements") and OpenAI ("maximize a single agent's capabilities first").
Hybrids are the norm
Real systems mix the shapes, and three hybrids cover most designs. Each one keeps the model's freedom inside a part of the system you can name. AWS's agentic AI patterns guide makes the same point about its own patterns: they are "building blocks that are often combined into hybrid architectures".
- A workflow with one agent step. On the service desk, the workflow handles every ticket and calls a bounded agent only for the "diagnose" step on tickets the classifier marks as unclear. Everything else stays a quote.
- An agent inside a workflow's guardrails. The workflow owns the trigger, the approval and the send, and the agent owns only the investigation. Microsoft's Cloud Adoption Framework puts approval gates, logging and audit trails in the workflow even when a single agent does the thinking: "Workflows provide essential structure for reliability and enterprise integration even with single agents."
- A lead agent with workers and one writer. Cognition calls its working version "map-reduce-and-manage: a manager splits work, children execute, the manager synthesizes and reports back."
A newer variant lets the model write the workflow and code run it: in Claude Managed Agents, dynamic workflows (beta) let an agent write a program that runs other agents, and "The program determines which agents run next". Durable-execution engines show the second hybrid most plainly: Temporal's OpenAI Agents SDK integration runs the agent inside a durable workflow, where "model calls are executed as Activities".
Worked example: Nehemvix, a fixed workflow by design
AELSHA™ NEHEMVIX, free to use with your own AI model key, answers the five questions at the lowest rung. Nehemvix runs as a fixed workflow, not an agent loop: the steps are set in code, the model that writes never calls a tool or chooses the next step, and the checks run in code, so a guide cannot grade itself. Its 14 steps run in LangGraph, and code decides every next step, including the two places where the plan can loop back. In a guide run the model is called in four steps (summarising files, combining folders, turning folder summaries into an architecture of the project, writing sections), plus two code-triggered retries: a re-ask for a reply that isn't valid JSON, and a rewrite of a section whose code names fail the check, kept only if code accepts it. The one approval comes before any model call: a cap a person approves in the web app ($1 by default, $50 at most), or a limit set beforehand for the API, command line or a local assistant. Progress is saved as each piece of work finishes, so a pause, a crash or a model switch doesn't redo or re-bill finished work, apart from calls in flight and, on the hosted service, the last few seconds before an instance is lost.
Citations are resolved at one pinned commit, and one that fails stays plain text under Caveats; names written as code are checked against the repository; the score is computed in code. Its own evaluation caught 80.2% of planted invented names (85 of 106) on the first blind run, 94.3% (100 of 106) after two rounds of fixes, and 83.1% (187 of 225) on a fresh held-out round; 6 of 376 real names were wrongly flagged at first, none after one fix. Plan with the held-out figure.
The fixed shape has costs. Nehemvix cannot change its plan beyond the two loop-backs or call tools to explore, so a question that needs running the code is out of its reach: no step can run it. Its name checks are exact for Python and pattern-based for other languages.
Tooling: choose the category before the product
Once the shape is chosen, the tooling question gets simpler, because each category answers a different question. Code-first frameworks ask where the control flow lives in code you test. Durable-execution engines ask what survives a crash or a week-long wait. Visual builders ask who can change the flow without a deploy. Products are named only as examples of each category; this is not a ranking. Alongside them sit managed agent runtimes, such as Amazon Bedrock AgentCore Runtime, Claude Managed Agents, Google's Agent Runtime and Microsoft Foundry Agent Service, which host the agent loop for you; judge them by where session state lives, which identity the agent acts under, and how hard they are to leave.
Code-first graph and agent frameworks
Choose this category when the flow is part of your product: version-controlled, reviewed and tested like the rest of your code. LangGraph models it as a graph whose checkpointers save state between steps. Google ADK's graph-based workflows combine "AI-powered agent reasoning with deterministic tools and code". Microsoft Agent Framework workflows "define explicit, inspectable execution paths". The OpenAI Agents SDK has no graph primitive: you orchestrate in code, call specialists as tools, or use handoffs. CrewAI's Flows offer "structured, event-driven workflows".
Durable-execution engines
Choose this category when the process is long-running, crosses several systems, and the model is one step among many. Temporal's description of durable execution is the clearest: "Once a Workflow starts, it runs to completion, whether that takes a second or a year." AWS Step Functions Standard Workflows suit "long-running (up to one year), durable, and auditable workflows", with an optimized Amazon Bedrock integration for model calls. Azure Durable Functions "manages state, checkpoints, retries, and recovery". Google Cloud Workflows "can hold state, retry, poll, or wait for up to a year". The cost is a programming model with rules: in Temporal, "A Workflow Definition must be deterministic because Temporal reruns it to rebuild state after a failure", so model calls belong in activities.
In every category, a step with a side effect can run twice: after a crash in checkpointing frameworks, and on activity retry in durable engines. Temporal recommends that an activity be idempotent "so retries can be processed without duplicate side effects", and Durable Functions warns that if a failure lands before an activity's result is recorded, "the runtime might rerun it". Give every such step an idempotency key; the graph engineering note shows how.
Visual and low-code builders
Choose this category when an operations or business team owns an integration-heavy flow and changes it often. n8n is the common example; check three things first:
- The licence. n8n is published under its Sustainable Use License, which it calls fair-code, and it says plainly: "we do not call ourselves open source". You may use it "only for your own internal business purposes or for non-commercial or personal use". Letting your customers connect their accounts and build workflows on it falls outside that, per its licence FAQ, and needs a commercial agreement.
- Hosting. n8n runs as n8n Cloud or self-hosted, and paid enterprise features are available on both.
- Change control. Git-based source control and environments are "Available on Business and Enterprise plans". n8n also ships evaluations for testing AI workflows against known cases.
AWS (Amazon Bedrock Flows), Google Cloud (Workflow Builder in Gemini Enterprise) and Microsoft (Copilot Studio) each offer one. Visual builders also carry platform risk. OpenAI's Agent Builder, "a visual canvas for building multi-step agent workflows", is being withdrawn: OpenAI's deprecations page records the announcement on 3 June 2026 and a shutdown scheduled for 30 November 2026. It does offer a way out: you can "download the SDK code to run it yourself". Before you build on any canvas, check that it has an exit like that.
Criteria by category
| Criterion | Code-first frameworks | Durable-execution engines | Visual and low-code builders |
|---|---|---|---|
| Who changes the flow | Engineers, through code review | Engineers, through code or a state-machine definition | Operations or business builders, in an editor |
| How you test it | Unit and integration tests in your own pipeline | The same, plus the engine's execution history | Built-in testing varies; check whether flows can run in your pipeline |
| What survives a crash | What your checkpointer saved, between steps | Workflow state and history, kept by the engine; activities may run more than once | Depends on the product and plan; check before relying on it |
| Where the model sits | In any node, or a bounded agent loop inside one | Usually in an activity or task, one step among many | In an agent or model node on the canvas |
| Licence and hosting | Packages you host; LangGraph, ADK, Agent Framework, the OpenAI Agents SDK, CrewAI and Strands use MIT or Apache 2.0 | Open-source engines or managed cloud services | Read the licence: source-available is not open source |
| Lock-in to check | Resume and interrupt semantics; prompt and tool-schema portability (MCP vs A2A) | The workflow language or SDK, and history retention | Export format, Git support, prompt and tool-schema portability, the vendor's roadmap |
An architect's checklist
Run this list against the next agent proposal that lands on your desk, and do item 1 on paper: beside each step, write who chooses what runs next, then mark every place where a model chooses but code could. Item 2 is the test for each mark. Without real cases that show the lower shape failing, the step goes back to code.
- Can you name, for every step, who chooses what runs next: code, one model or several?
- Does a labelled set of real cases show the lower shape failing, and can you trace one item end to end with its cost? (AgentOps)
- For each agent, are the tool list, turn cap and spend cap set in code, with a budget for the whole night?
- Does a multi-agent design rest on a named boundary, and exactly one writer?
- Do you need a quote before the run or a cap during it, and where does a capped run go?
- Can untrusted input choose a tool?
- Is every output checked by something the producing model cannot influence?
- Does every step that changes the outside world sit behind a check or an approval, and is it safe to run twice?
If you have the cases and still cannot decide, send us the marked-up proposal; we reply by email.
Further reading
- Towards a science of scaling agent systems, Google Research: A controlled study of when adding agents helps and when it hurts, by task type.
- How we built our multi-agent research system, Anthropic: The strongest published case for multi-agent, with its costs and its limits stated by the team that built it.
- Multi-Agents: What's Actually Working, Cognition: A year-later update from the authors of "Don't Build Multi-Agents", on the narrow patterns that now work.
- Why Do Multi-Agent LLM Systems Fail?, Cemri et al.: 14 failure modes from more than 1,600 traces, usable as a design-review checklist.
- AI agent orchestration patterns, Microsoft: A map from direct model calls to multi-agent patterns, with each level's trade-offs.
- Agentic AI examples: one production agent, measured, AELSHA™ NEHEMVIX: One production system's steps, tools, human approval, pauses and evals, as a worked example of a fixed workflow.
Of everything here, the ADK and Agent Builder status, the Managed Agents beta and the token rate will date first. Check the vendor's page for the version you run before you build on one of them.
