Workflows vs Agents: Start Simple

Introduction

In L113 (Workflow vs Agent) you learned the most important cost decision: most tasks that need more than one LLM call are workflows, not agents. This lesson opens the toolkit. Between "one prompt" and "a full autonomous agent" sits a small, powerful set of workflow patterns — predictable, composable ways to wire LLM calls together — and they handle the vast majority of real "more-than-one-call" problems.

The whole philosophy, straight from Anthropic's Building Effective Agents, is two words: start simple. "Find the simplest solution possible, and only increase complexity when needed." You begin with the simplest building block and compose upward only as the task forces you to — never reaching for an autonomous loop when a predictable path will do.

This lesson is the map for the next several. In it:

The building block everything is made of — the augmented LLM
The five workflow patterns (chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer) — a quick tour; each gets its own lesson
How patterns compose, and where the agent sits
The start-simple discipline, and the honest 2026 reality check

An infographic titled 'Workflows vs Agents: Start Simple' — the map for the workflow-patterns section. You need more than one LLM call, but before reaching for a full agent there is a toolkit of simpler, predictable workflow patterns; start simple and compose up only as needed. THE BUILDING BLOCK is the augmented LLM: in to (LLM + tools + retrieval + memory) to out — every pattern is just this atom wired together by your code. THE 5 WORKFLOW PATTERNS (Anthropic), predefined code paths in increasing complexity: 1 Prompt Chaining (split into fixed ordered steps, each builds on the last, with gates); 2 Routing (classify the input, send to a specialized handler); 3 Parallelization (run subtasks at once — sectioning, or voting for confidence); 4 Orchestrator-Workers (a lead LLM splits work it cannot predict, delegates to workers, synthesizes); 5 Evaluator-Optimizer (generate, critique, improve, looping to a quality bar). These are workflows — you write the control flow — predictable, testable, roughly fixed cost — and they compose and nest. An agent is the open-ended top of the ladder where the LLM directs its own loop; reach for it only when you genuinely cannot predict the steps. The 2026 reality check: agents have matured (MCP, code-execution) but the start-simple rule got stronger — infinite loops, hallucinated tool calls and runaway spend do not exist in deterministic systems, and self-orchestrating agents on big tasks skip steps, make circular dependencies, and stall in analysis loops, so keep the orchestration layer deterministic and reserve agent autonomy for steps you cannot script. Start with the augmented LLM, compose the five predictable patterns as the task demands, and reach for a full agent last.

The Building Block: The Augmented LLM

Before the patterns, the atom they're all built from. Anthropic calls it the augmented LLM: "the basic building block of agentic systems is an LLM enhanced with augmentations such as retrieval, tools, and memory." Crucially, the model doesn't just have these — it actively uses them, "generating its own search queries, selecting appropriate tools, and determining what information to retain."

📚 Retrieval — pull in relevant knowledge it wasn't trained on (RAG, Container 2).
🔧 Tools — call functions to act and to fetch live data (Container 3, next sections).
🧠 Memory — carry state across turns and steps.

One enhanced call — knowledge in, tools available, memory attached:

# The AUGMENTED LLM — the atom every pattern is built from.
resp = client.messages.create(
    model="claude-opus-4-8",
    tools=[search_tool, calculator],                 # 🔧 tools it can call
    messages=[
        *memory,                                     # 🧠 memory (prior turns / state)
        {"role": "user",
         "content": f"{retrieved_docs}\n\nQ: {query}"},  # 📚 retrieval, injected
    ],
)
# An LLM that can pull in knowledge, call tools, and remember. Everything below
# is just this call, used MORE THAN ONCE and wired together by YOUR code.

Anthropic's one piece of advice here: give the model an easy, well-documented interface to these augmentations, tailored to your use case. Get the atom right and every pattern below becomes a matter of how you wire these calls together.

The Five Workflow Patterns (A Quick Tour)

A workflow orchestrates augmented-LLM calls through predefined code paths — you write the control flow. Anthropic catalogues five patterns, in roughly increasing complexity. Here's the map (each gets a full lesson next, so this is just the shape and the trigger):

#	Pattern	What it does	Use when	Example
1	⛓️ Prompt Chaining	Fixed sequence; each step processes the last, with gates	The task splits cleanly into fixed ordered subtasks	Write copy → translate it
2	🔀 Routing	Classify input → dispatch to a specialized handler	There are distinct categories better handled separately	Refund / tech / general support
3	🔱 Parallelization	Run calls at once — sectioning or voting	Subtasks parallelize for speed, or you want multiple perspectives	One answers + one screens; vote on code vulns
4	🧑‍✈️ Orchestrator–Workers	A lead LLM splits work, delegates, synthesizes	You can't predict the subtasks up front	Code changes across an unknown set of files
5	♻️ Evaluator–Optimizer	Generate → evaluate → refine in a loop	Clear eval criteria + iteration measurably helps	Literary translation, refining nuance

Two things to notice already: (1) patterns 1–3 have fully fixed control flow — the steps are known before you run. (2) Patterns 4–5 add a bounded amount of model-driven dynamism (the orchestrator decides subtasks; the loop runs until a bar) — but they're still workflows, because you wrote the orchestration and the stop conditions, not the model.

Explore the Toolkit

Click through the building blocks below — from the augmented-LLM atom, up through the five patterns, to the open-ended agent at the top. For each, you'll see its shape, when to use it, and a concrete example. Watch the control flow get progressively more dynamic as you climb:

Click each building block — from the augmented-LLM atom, up through the five workflow patterns, to the open-ended agent — to see its shape, when to use it, and a concrete example. Notice the patterns are all predefined code paths; only the agent hands control of the flow to the model.

The single most useful thing to internalize from this map: the five patterns are predefined code paths — you own the flow. Only the agent (the last item) hands control of the flow to the model. That line — who decides what happens next — is the entire difference between a workflow and an agent.

Workflows Compose (and Nest)

These patterns aren't a menu you pick one from — they're building blocks that combine. A router's branches can be chains; an orchestrator's workers can vote; a chain can have an evaluator-optimizer loop as one of its steps. Real systems are compositions of these primitives, wired by ordinary code:

# A WORKFLOW = your code wires augmented-LLM calls along a PREDEFINED path.
# Here three patterns compose into one support pipeline:
def handle_ticket(ticket):
    route = classify(ticket)                         # 🔀 ROUTING
    if route == "refund":
        # ⛓️ PROMPT CHAINING — fixed ordered steps, each builds on the last
        order = verify_order(ticket)
        draft = draft_refund(ticket, order)
        return tone_check(draft)
    if route == "bug":
        # 🔱 PARALLELIZATION — independent reviews at once, then merge
        reviews = run_parallel(security_review, perf_review, repro_check)(ticket)
        return summarize(reviews)
    return draft_reply(ticket)
# Predictable, testable, ~fixed token budget. No autonomous loop in sight.

That's the power of starting simple: because each pattern is just your code calling augmented LLMs on a known path, you can nest and combine them freely, test each piece, and keep the whole thing predictable and debuggable — exactly the properties an autonomous agent gives up. The augmented LLM is the atom; the patterns are the molecules; your control flow is the structure.

Start Simple — the Discipline (and the 2026 Reality Check)

The meta-rule that governs this whole section: start with the simplest building block, and climb only when the task demonstrably forces you to. Single call → augmented call → a workflow pattern → composed patterns → (only if you truly can't predict the steps) an agent. "Agentic systems often trade latency and cost for better task performance; consider when that tradeoff makes sense."

And here's the honest, current nuance — because it's tempting to think "it's 2026, agents are good now, just use an agent." Agents have matured (native tool-calling, MCP as the standard tool protocol, code-execution for efficiency). But the start-simple rule got stronger, not weaker, and the evidence is blunt:

"Infinite reflection loops, hallucinated tool calls, and runaway token spend do not exist in deterministic systems." A workflow simply cannot suffer the failure modes from L114 — because the control flow isn't up to the model.
In practice, when teams let agents self-orchestrate big tasks (large codebases, cross-cutting changes), the agents "routinely skipped steps, created circular dependencies, or got stuck in analysis loops."
The hard-won lesson: keep the orchestration layer deterministic — let workflows decide what comes next — and reserve the model's autonomy for the individual steps you genuinely can't script.

So the maturing of agents didn't make workflows obsolete — it sharpened the boundary. Use the predictable patterns for the control plane; use agentic autonomy as a bounded ingredient inside it, where it earns its keep. Start simple is not a beginner's crutch; it's what experienced teams keep choosing.

🧪 Try It Yourself

Map each task to the simplest pattern that fits — name it, and say why nothing simpler works. Use the explorer to check the shapes.

Take a blog post, summarize it, then turn the summary into a tweet thread — same three steps every time.
An incoming email is a sales lead, a support request, or spam — handle each completely differently.
Draft a tricky legal clause, then keep improving it until it satisfies a checklist of 8 requirements.
Review a PR for bugs, security, and style — and you want all three opinions fast.
"Research this company and write a tailored outreach plan" — you don't know in advance how many sources or steps it'll take.

→ (1) Prompt Chaining — a fixed ordered sequence (summarize → threadify). (2) Routing — classify into distinct categories, dispatch to separate handlers. (3) Evaluator–Optimizer — a clear criteria checklist + iterative refinement is exactly its sweet spot. (4) Parallelization (sectioning) — three independent reviews at once, then merge (speed + perspectives). (5) This is the one that earns more than a fixed pattern: the subtasks are unpredictable, so Orchestrator–Workers (a lead LLM decides the subtasks) — and if it's truly open-ended, it tips into a full agent. Notice four of five are plain workflows.

Mental-Model Corrections

"More than one LLM call = an agent." No — chaining, routing, and parallelization are workflows (predefined paths). An agent is specifically when the model controls the flow.
"The five patterns are alternatives — pick one." They're composable building blocks. Real systems nest them (a router of chains; an orchestrator of voting workers).
"Orchestrator-workers and evaluator-optimizer are agents." They have bounded dynamism, but you wrote the orchestration and stop conditions — they're workflows. The agent is the open-ended loop where the model decides each step.
"It's 2026, agents are good now — just use an agent." Agents matured, but deterministic workflows can't loop, hallucinate tool calls, or overspend. Keep the orchestration deterministic; use autonomy as a bounded ingredient.
"Start simple is for beginners." It's what experienced teams keep choosing — simpler systems are cheaper, more reliable, and easier to debug. Complexity is a cost you justify, not a default.
"The augmented LLM is just an LLM." It's the LLM plus retrieval, tools, and memory, which it actively uses — that's the atom every pattern (and every agent) is built from.

Key Takeaways

Start simple. Between one prompt and a full agent sits a toolkit of predictable workflow patterns that handle most real needs. Find the simplest solution; add complexity only when it demonstrably improves outcomes.
The building block is the augmented LLM — an LLM that actively uses retrieval, tools, and memory (give it a clean, well-documented interface).
The five patterns: ⛓️ Prompt Chaining (fixed sequence), 🔀 Routing (classify → handler), 🔱 Parallelization (sectioning / voting), 🧑‍✈️ Orchestrator–Workers (delegate unpredictable subtasks), ♻️ Evaluator–Optimizer (generate → critique → refine).
They're workflows — you own the control flow (predefined code paths): predictable, testable, ~fixed cost — and they compose and nest. The agent is the open-ended top, where the model owns the flow.
2026 reality check: agents matured, but the start-simple rule strengthened — keep the orchestration deterministic (workflows can't loop/hallucinate/overspend); reserve autonomy for steps you can't script.
Next: we build each pattern from scratch, starting with the simplest — Prompt Chaining.