Building Effective Agents: Workflows, Agents and the Patterns Between

1. One distinction to rule the field

Published in December 2024, Building Effective Agents became the reference everyone cites because it cut through the hype with one clean distinction:

• Workflows are systems where LLMs and tools are orchestrated through predefined code paths. You decide the steps; the model fills them in.
• Agents are systems where the model directs its own process — it decides which tools to use, in what order, and when it’s done.

Most “agent” products are workflows, and that’s not an insult — the essay’s strongest advice is to find the simplest solution possible and only add complexity when simpler fails. Autonomy costs latency, tokens and predictability; spend it only where the task genuinely can’t be pre-decomposed. (For that decision checklist, see Prompting for Agents.)

2. The five workflow patterns

The essay catalogs five composable patterns between “single prompt” and “full agent”:

Prompt chaining — decompose a task into fixed steps, optionally with programmatic checks (“gates”) between them. Fit: tasks that decompose cleanly — outline → validate outline → write.

Routing — classify the input first, then dispatch to a specialized prompt/model. Fit: distinct input categories needing different handling — support tickets by type, easy questions to a fast model, hard ones to a stronger one.

Parallelization — run LLM calls concurrently: sectioning (split independent subtasks) or voting (same task multiple times, aggregate for confidence). Fit: speed via independence, or higher-stakes judgments — e.g., several reviewers each checking a different concern.

Orchestrator–workers — a central LLM dynamically decomposes the task and delegates to worker calls, then synthesizes. Unlike parallelization, the subtasks aren’t known in advance. Fit: “make this change across however many files it touches.”

Evaluator–optimizer — one call generates, another critiques against criteria, loop until accepted. Fit: when you can articulate what “better” means — translation polish, search-result refinement.

Only when even orchestrator–workers can’t pre-structure the problem do you reach for an agent: the model operating tools in a loop, gaining ground truth from the environment at each step, with budgets and stopping conditions as guardrails.

3. The agent–computer interface

The essay’s most under-appreciated section argues that tool design deserves the same care as human interface design. The model experiences your tools the way users experience your UI — and most “dumb agent” behavior is actually bad ACI:

• Formats matter. Choose tool input/output formats close to what the model has seen in training, and give it room to think before committing to rigid output.
• Naming and descriptions matter. Write tool descriptions like docstrings for a junior engineer: when to use it, when not to, what the parameters mean, examples and edge cases.
• Make misuse hard. If a parameter keeps being filled wrong, don’t add prompt scolding — change the parameter. (Their example: requiring absolute file paths ended a class of errors that relative paths kept causing.)
• Test tools in isolation. Run many example calls and read what the model actually does with your interface before blaming the model.

mkdir agent-patterns && cd agent-patterns
python3 -m venv .venv && source .venv/bin/activate
pip install anthropic
export ANTHROPIC_API_KEY="sk-ant-..."

import anthropic

client = anthropic.Anthropic()

def ask(prompt: str, system: str = "") -> str:
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1500,
        system=system or anthropic.NOT_GIVEN,
        messages=[{"role": "user", "content": prompt}],
    )
    return response.content[0].text

from llm import ask

topic = "Why simple LLM workflows beat premature agents"

outline = ask(
    f"Write a 5-section outline for a short technical article about: {topic}. "
    "One line per section, numbered."
)

# Gate: cheap deterministic check between steps — fail fast, don't propagate junk
lines = [line for line in outline.splitlines() if line.strip()]
if not 4 <= len(lines) <= 7:
    raise SystemExit(f"Gate failed: outline has {len(lines)} sections:\n{outline}")

article = ask(
    f"Write the article following this outline exactly. Keep it under 400 words.\n\n{outline}"
)
print(article)

import json
from llm import ask

HANDLERS = {
    "refund": "You are a refunds specialist. Be empathetic, confirm the order id, state the 14-day policy.",
    "bug": "You are technical support. Ask for reproduction steps, app version and platform.",
    "sales": "You are a friendly sales rep. Answer briefly and offer a demo call.",
}

def route(email: str) -> str:
    verdict = ask(
        "Classify this email as exactly one of: refund, bug, sales. "
        'Reply with JSON only: {"category": "..."}\n\n<email>' + email + "</email>"
    )
    category = json.loads(verdict)["category"]
    print(f"[router] → {category}")
    return ask(f"<email>{email}</email>\n\nWrite the reply.", system=HANDLERS[category])

print(route("Hey, the app crashes whenever I open settings on Android 15."))

Where to go next

• Read the original essay — short, and the appendix on coding agents is gold.
• See the decision framework for when to go full agent in Prompting for Agents.
• When your agent needs standardized tool access, that’s MCP 201.