Agent vs Workflow¶

The first design decision is not "which framework?" but who decides what happens next — the code or the LLM?

Anthropic, OpenAI, and Google agree on the rule: start with the simplest solution and increase complexity only when data proves it is necessary [Anthropic, 2024; OpenAI, 2025; Google, 2026].

Workflow¶

In a workflow, the developer defines every step. The LLM executes a step, but the code decides which step comes next. The path is predefined [Anthropic, 2024].

Workflows are predictable, testable, and auditable. Use them when the steps are known and the failure cost of a wrong branch is high [Google, 2026].

Agent¶

In an agent, the LLM decides what to do next. It selects tools, sequences calls, and loops until it decides the task is done. The developer gives a goal and guardrails, not a path [Anthropic, 2024].

Agents trade latency and cost for flexibility. They are the right choice when the task is open-ended and the required steps cannot be enumerated at build time [Anthropic, 2024].

The spectrum¶

Most real systems sit on a spectrum between the two. Google ADK and OpenAI Agents SDK both support:

Workflow agents (SequentialAgent, ParallelAgent, LoopAgent) that run sub-agents through predefined code paths.
LLM agents (LlmAgent / Agent) that choose the next action at runtime.
Hybrid architectures: a deterministic workflow provides the overall structure, and an LLM agent handles the variable, judgment-intensive step inside it [OpenAI, 2025; Google, 2026].

The seven-level ladder¶

The transcript organizes common agentic patterns into a ladder. Each step solves a problem the previous one could not, but each step also adds cost, latency, and unpredictability.

Kroki

Level 1 — Single LLM call¶

One input, one output. The model may have tools and retrieval, but the conversation is a single turn.

Use when the task is one-shot: summarization, classification, a single tool lookup.
Stop here if one call is enough [Anthropic, 2024].

Level 2 — Prompt chain¶

The task decomposes into a fixed sequence. The output of step N is the input of step N+1. Gates can verify intermediate results.

Example: the barista gathers context from calendar and Slack, determines team needs, forms an order, and asks a human for confirmation.
Use when the task is predictable and needs higher accuracy than one call can deliver [Anthropic, 2024].

Level 3 — Router¶

A small classifier routes the request to a specialized chain. The classifier can be a cheap, fast model.

Example: "I want coffee" goes to the order chain; "I have a nut allergy" goes to the preference-update chain.
Use when the input has distinct categories that need different handling [Anthropic, 2024].

Level 4 — Parallelization¶

Independent subtasks run at the same time and their results are aggregated.

Example: the barista calls calendar, Slack, weather, and RAG APIs in parallel because none depends on another.
Use when tasks are independent and sequential latency is wasteful [Anthropic, 2024].

Level 5 — Orchestrator-workers¶

A central LLM decomposes the task dynamically, dispatches worker calls, and synthesizes the results. The subtasks are not hardcoded.

Example: for a flooded-apartment insurance claim, one worker checks the policy, another finds an assessor, a third drafts a statement.
Use when the subtasks cannot be predicted from the input [Anthropic, 2024].

Level 6 — ReAct agent¶

The LLM chooses tools, observes results, and repeats until it decides to answer. No fixed path.

Example: "Organize a retro coffee break" triggers checks for preferences, menu, budget, and alternatives.
Use for open-ended tasks where the sequence cannot be predefined. This is where cost and risk jump [Anthropic, 2024].

Level 7 — Multi-agent¶

Several agents work in parallel. One refactors code, another writes tests, a third updates docs.

Use only when coordination across independent sources or domains is required. A single agent with simple tools is often more effective [Anthropic, 2024].

OpenAI adds a useful refinement: when you do need multiple agents, choose between handoffs (the specialist owns the next response) and agents as tools (a manager keeps control and calls specialists as bounded capabilities) [OpenAI, 2025].

When to stop¶

Start at Level 1. Move up only when the current level cannot solve the task with acceptable cost and risk. Every step up is a trust decision.

Level	Typical LLM calls	Predictability	Cost	Use when
1	1	High	$	One-shot, well-defined output
2	2–5	High	$	Fixed subtasks with verifiable gates
3	1 + cheap classifier	High	$	Distinct input categories
4	2–8 in parallel	High	$$	Independent subtasks, latency-sensitive
5	5–15	Medium	$$–$$$	Subtasks cannot be hardcoded
6	5–25+	Low–Medium	$$$	Open-ended, dynamic tool use
7	10–50+	Low	$$$$	Multiple independent domains or policies

Decision tree¶

Do you know all the steps before the request arrives?
Yes → workflow. No → agent.
Can the required subtasks be enumerated?
Yes → prompt chain, router, or parallelization. No → orchestrator-workers or ReAct agent.
Does a wrong decision cause high damage (money, data, compliance)?
Yes → keep a human or deterministic gate in the path; do not give the LLM unbounded control [Google, 2026].
Is the task exploratory and the output hard to verify automatically?
Yes → use an agent, but with strict budgets and a human escalation path.
Do multiple specialists need different tools or policies?
Yes → consider multi-agent, but start with one agent and add specialists only when the contract changes [OpenAI, 2025].

Common mistakes¶

Defaulting to the most complex pattern because it is more impressive. Start simple and add complexity only with data.
Building a fully autonomous agent for a well-defined task — expensive, inconsistent, hard to audit [Google, 2026].
Building a rigid workflow for an exploratory task — it breaks on edge cases and requires constant patches [Google, 2026].
Splitting into multi-agent too early — more prompts, more traces, more approval surfaces without proportional benefit [OpenAI, 2025].

Summary¶

Agentic systems are not a single thing; they are a spectrum. Most production systems in 2026 are hybrid: a deterministic workflow provides structure, and one or two agentic nodes handle the steps that cannot be enumerated. Pick the simplest level that solves the task, then instrument cost, latency, and risk before moving up the ladder.

Deeper dive: the autonomy ladder and when to climb it¶

Both research and production practice in 2026 frame the design choice not as a binary agent-versus-workflow decision, but as a complexity spectrum from deterministic code to autonomous multi-agent systems. The rule is to stay as far to the left—toward the simplest architecture—as the task allows, and to climb right only when the current rung fails [Iusztin and Bouchard, 2026; Knowlee, 2026].

A workflow remains the right starting point when the steps are known and stable. It is predictable, cheap, testable, and can be extended with routing, parallel fan-out, generator-evaluator loops, and even orchestrator-worker patterns without adding an autonomous decision layer [Iusztin and Bouchard, 2026]. When the path cannot be predetermined, a single agent with typed tools is usually the next step; the tools themselves may contain their own prompts, validators, or models, so a single cognitive loop can still handle surprising subtasks. In most production SaaS features this pattern is actually a hybrid: one agent performs judgment, and deterministic tools, scripts, or workflows carry out bounded multi-step work [Knowlee, 2026].

Multi-agent is justified only by specific constraints, not by the number of tools or the impressiveness of the architecture. Useful triggers include true parallelism, context-window overload from too many tools or instructions, integration of third-party agent runtimes you do not control, and hard separation requirements such as security boundaries or sensitive data handling [Iusztin and Bouchard, 2026]. Knowlee's prompt-count test is a practical rule of thumb: one model-prompt-and-tools loop is single-agent or hybrid; two or more cognitive loops connected by structured handoffs are multi-agent [Knowlee, 2026]. When you do need multiple agents, the dominant production shape is an orchestrator with specialists, not peer-to-peer chatter.

Climb the autonomy ladder only when you hit one of these real limits:

One-shot or fixed sequence still fits → stay with a workflow.
Dynamic path, single expertise, and <10–20 tools → use one agent with tools, including smart validators.
One kind of judgment, but deterministic parts are complex → wrap them as structured tools around a hybrid agent.
Three or more distinct kinds of expertise, real parallelism, context limits, or hard separation → consider a foreman/orchestrator multi-agent system [Knowlee, 2026; Iusztin and Bouchard, 2026].

References¶

Anthropic. "Building Effective AI Agents." Dec 2024. https://www.anthropic.com/engineering/building-effective-agents
Google. "LLM Agents vs. Workflows — and How Google ADK Gives You Both." Google Cloud, Apr 2026. https://medium.com/google-cloud/llm-agents-vs-workflows-and-how-google-adk-gives-you-both-7301d6fb1c4c
Google. "Template agent workflows." Google ADK Docs, 2026. https://github.com/google/adk-docs/blob/main/docs/agents/workflow-agents/index.md
HumanLayer. "12-Factor Agents." https://github.com/humanlayer/12-factor-agents
OpenAI. "Orchestration and handoffs." OpenAI API docs, 2025. https://developers.openai.com/api/docs/guides/agents/orchestration
Iusztin, Paul, and Louis-François Bouchard. "From 12 Agents to 1: AI Agent Architecture Decision Guide." Decoding AI, 26 Mar 2026. https://www.decodingai.com/p/from-12-agents-to-1-ai-agent-architecture-decision-guide
Knowlee. "Single-Agent vs Multi-Agent: A Decision Framework (2026)." Knowlee Blog, 30 Apr 2026. https://www.knowlee.ai/blog/single-agent-vs-multi-agent-decision-framework