Study guide

2.1 Workflows vs Agents

Claude Certified Architect - Foundations Study Guide Exam

Track your progress as you read

Finished sections get a check mark.

1 Chapter 1: Exam and Ecosystem Overview

1.1 Certification Context 1.2 Study Map

2 Chapter 2: Agentic Architecture and Orchestration

2.1 Workflows vs Agents 2.2 Agentic Loops and the Claude Agent SDK 2.3 Multi-Agent Orchestration and Session Management

3 Chapter 3: Claude Code Configuration and Workflows

3.1 Claude Code Workflows

4 Chapter 4: Tool Design and MCP Integration

4.1 Tool Design and MCP Integration

5 Chapter 5: Prompt Engineering and Structured Output

5.1 Prompt Engineering 5.2 Structured Output and Evaluation

6 Chapter 6: Context Management and Reliability

6.1 Context, Caching, and Compaction 6.2 Model Selection and Reliability

2.1 Workflows vs Agents

Key Takeaways Explain This Topic AI

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.

Last updated: June 2026

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.