2.1 Workflows vs Agents
Key Takeaways
- Anthropic defines five workflow patterns (prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer) plus the autonomous agent; the CCA-F tests which one fits a scenario.
- A workflow runs LLM calls and tools through predefined code paths; an agent lets the model dynamically direct its own process and tool use in a loop.
- The guiding principle is 'find the simplest solution possible, and only increase complexity when needed' — start with a single augmented LLM call before reaching for an agent.
- Orchestrator-workers fits tasks whose subtasks cannot be predicted in advance; routing fits inputs that fall into known categories; evaluator-optimizer fits tasks with clear, iterable success criteria.
The Building Block: An Augmented LLM
Everything in Anthropic's Building Effective Agents guide starts from one unit: an augmented LLM — a model call enhanced with retrieval (pulling in external context), tools (functions the model can invoke), and memory (state carried across turns). The CCA-F exam expects you to reason up from this block rather than reaching for a framework. The headline principle, quoted almost verbatim in scenario stems, is: find the simplest solution possible, and only increase complexity when needed.
The exam draws a sharp line between two categories. A workflow is a system where LLM calls and tools are orchestrated through predefined code paths — the developer wrote the control flow. An agent is a system where the model dynamically directs its own process and tool usage, looping on its own observations until it decides the task is done. Agents are more flexible but cost more in latency, tokens, and failure surface, so autonomy must earn its place.
The Five Workflow Patterns Plus the Agent
Memorize this table; roughly a third of architecture items map a scenario onto one row.
| Pattern | Mechanism | Use when |
|---|---|---|
| Prompt chaining | Output of one call feeds the next; optional programmatic gate between steps | The task decomposes into a fixed, known sequence |
| Routing | A classifier call directs input to one of several specialized prompts/models | Inputs fall into distinct categories handled better separately |
| Parallelization | Run subtasks concurrently (sectioning) or run the same task many times (voting) | Subtasks are independent, or you want diverse outputs aggregated |
| Orchestrator-workers | A central LLM dynamically breaks down the task and delegates to worker calls | The number/shape of subtasks cannot be predicted in advance |
| Evaluator-optimizer | One call generates, a second evaluates and gives feedback, loop repeats | There are clear evaluation criteria and iteration measurably improves output |
| Autonomous agent | Model plans, acts via tools, observes results, loops until a stop condition | Open-ended problems where steps cannot be hardcoded and you can sandbox/limit |
Worked Scenario
A team translates a document, then summarizes the translation, then extracts action items from the summary. Because the order is fixed and known, this is prompt chaining, not an agent — adding a programmatic check (e.g., verify the translation is non-empty) between steps is the textbook 'gate.' Contrast: a coding assistant that must fix a bug spanning an unknown number of files cannot enumerate its subtasks up front, so it needs orchestrator-workers or a full agent. A help desk that sorts tickets into billing, technical, and account access uses routing.
A pipeline that runs three independent reviewers over the same pull request and aggregates their verdicts is parallelization in its voting variant. A draft-and-critique loop that rewrites marketing copy until it clears a rubric is evaluator-optimizer.
Common Exam Traps
- Choosing an agent when a workflow suffices. If the steps are known, an agent is over-engineering — and the exam penalizes unnecessary autonomy.
- Confusing parallelization with orchestrator-workers. Parallelization has fixed, predefined subtasks run concurrently; orchestrator-workers discovers the subtasks at runtime.
- Confusing evaluator-optimizer with routing. Evaluator-optimizer loops on quality feedback; routing makes a one-time classification decision.
- Ignoring failure modes. Agents can loop forever, call the wrong tool, or burn context; workflows can be too rigid for variable input. A strong answer names the failure mode and picks the least complex design that still covers the real input distribution, often pairing the agent with stopping conditions and sandboxing.
When to Use an Agent At All
Anthropic's guidance is deliberately conservative: agents are appropriate for open-ended problems where you cannot predict the required number of steps and cannot hardcode a fixed path, where the cost of an occasional wrong action is acceptable, and where you can establish trust through testing. The exam frames this as a trade-off triangle of capability, cost, and control. More autonomy buys capability on messy problems but spends tokens and latency and weakens control. If a cheaper, more controllable workflow handles the realistic inputs, the workflow is the better engineering choice and the better exam answer.
Three guardrails recur in correct agent answers. First, stopping conditions — a maximum number of turns or a budget so the loop cannot run away. Second, sandboxing — run tool actions in an isolated environment so mistakes do not damage production. Third, human checkpoints — surface a plan or a diff for approval before irreversible actions. An agent answer that omits all three is usually a distractor.
Combining Patterns
These patterns compose. A production system might route an incoming request, run a prompt chain for one category, and wrap a generation step in an evaluator-optimizer loop where quality matters. The exam may describe a hybrid and ask which single pattern best names the highlighted behavior. Read for the verb: classify and dispatch is routing; generate then critique then regenerate is evaluator-optimizer; split into known parts and run together is parallelization; decide subtasks at runtime is orchestrator-workers; fixed ordered steps is prompt chaining.
Anchor on the mechanism the question is testing, not the overall system, and pick the least complex pattern that fits.
Why This Matters on the CCA-F
Agentic Architecture & Orchestration is the heaviest CCA-F domain at 27% of the exam, and architecture pattern selection is one of its most heavily weighted topics. The exam is 60 scenario-based multiple-choice questions in 120 minutes, scored on a scaled 1000-point system with 720 to pass.
The questions are written so that two options are technically workable but one is simplest for the stated requirement. Train yourself to eliminate the over-engineered choice first — if a fixed sequence solves it, an agent is wrong even though an agent could do it. That single discipline, simplicity-first, is the most reliable scoring habit for this chapter.
A support system classifies each incoming request as billing, technical, or account access, then sends it to a prompt specialized for that category. Which pattern is this?
A coding assistant must resolve a GitHub issue that may touch an unknown number of files, and the specific subtasks cannot be listed in advance. Which workflow pattern does Anthropic recommend?