What you will be able to do
- Tell a workflow from an agent by who controls the sequence of steps
- Explain why a single augmented LLM call is the default before any agentic design
- Identify the augmentations that make an LLM call the building block of every other pattern
- Weigh the latency and cost that agentic designs add against the task performance they buy
Key concept
Workflow vs. agent — Both are agentic systems. The difference is who controls the sequence of steps. In a workflow, your code fixes the path the LLM calls and tools follow. In an agent, the model decides its own steps and which tools to use as it goes.
1.One family, two kinds of control
People use "agent" for very different systems. Some mean fully autonomous systems that run for long periods with many tools. Others mean prescriptive implementations that follow a predefined workflow. Anthropic calls all of these agentic systems, then splits them along one architectural line. Workflows run LLMs and tools through code paths you wrote in advance. Agents are systems where LLMs dynamically direct their own processes and tool usage.
So the test is not how many LLM calls there are, or how many tools. The test is who decides what happens next. If your code decides the sequence (call A, check its output, then call B), you have a workflow, however elaborate it is. If the model decides whether to search again, which tool to call, or when it has finished, you have an agent.
Each side has its own strengths. Workflows give you predictability and consistency on well-defined tasks. Agents are the better option when you need flexibility and model-driven decisions at scale. Claude's prompting guidance gives a concrete reason to keep the path in your own code: explicit chaining of API calls is still useful when you need to inspect intermediate outputs or enforce a specific pipeline structure. Requirements like auditability, fixed compliance steps, or a mandatory review gate between stages point to a workflow.
It is a workflow. The number of calls and the presence of tools don't matter. Code fixed the sequence in advance, so the LLM is not directing its own process.
A content team needs marketing copy generated and then translated into three languages, with a programmatic check confirming each translated string stays within a fixed UI character limit before it is published. Which architectural pattern best fits this requirement?
Correct answer: A — Prompt chaining, using sequential LLM calls with a programmatic gate that checks translated text length before publishing
- A. Correct. The task decomposes into fixed sequential steps (generate, then translate) with a deterministic, programmatic validation gate between them, which is the defining shape of prompt chaining.
- B. Incorrect. Routing classifies an input to send it down one of several specialized paths; there is no classification decision here, only a fixed sequence of steps.
- C. Incorrect. Orchestrator-workers dynamically determines subtasks at runtime; the languages and steps here are already known and fixed, not discovered dynamically.
- D. Incorrect. Evaluator-optimizer uses a second LLM to iteratively critique and refine output; the scenario describes a deterministic length check, not an LLM-based quality feedback loop.
2.Start from the simplest thing that works
Anthropic's first recommendation is to find the simplest solution possible and add complexity only when it is needed. That can mean building no agentic system at all. The reason is a tradeoff you should state out loud in any design: agentic systems often trade latency and cost for better task performance. That trade only makes sense when the performance gain is worth what you pay for it.
In practice, the baseline for many applications is one well-built LLM call. Retrieval supplies the right context and in-context examples show the expected output. Only when that baseline falls short do you move to a workflow. You move to an agent only when the task needs model-driven decisions that a fixed path cannot capture. Current Claude models make that baseline stronger than it used to be, because with adaptive thinking and subagent orchestration they handle most multistep reasoning internally.
| Option | What controls the steps | When it fits |
|---|---|---|
| Single LLM call with retrieval and in-context examples | One call; no sequencing needed | Often enough for many applications |
| Workflow | Predefined code paths | Well-defined tasks where predictability and consistency matter |
| Agent | The LLM directs its own process and tool usage | Flexibility and model-driven decision-making needed at scale |
Frameworks raise the same concern. Tools such as the Claude Agent SDK, Strands Agents SDK, Rivet and Vellum take care of low-level work like calling LLMs, parsing tools and chaining calls. But they add layers that can hide the prompts and responses underneath, and they make it tempting to add complexity a simpler setup would not need. Anthropic's advice is to start with the LLM APIs directly, since many patterns take only a few lines of code. If you do use a framework, understand what it does underneath.
3.The augmented LLM: the block everything is built from
Every workflow and agent pattern is built from the same unit: an LLM enhanced with retrieval, tools, and memory. This is the augmented LLM. Current models use these capabilities actively. They generate their own search queries, select appropriate tools, and decide what information to keep. The patterns you meet later (chaining, routing, orchestrator-workers) all assume that each LLM call inside them has these capabilities.
Tools are the most concrete of these augmentations. Claude decides when to call a tool from the user's request and the tool's description. The tool then runs in one of two places. Client tools run in your application: Claude returns a tool_use block, your code runs it, and you send back a tool_result. Server tools, such as web search, run on Anthropic's infrastructure and return results directly.
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-opus-5-5",
max_tokens=1024,
tools=[{"type": "web_search_20260209", "name": "web_search"}],
messages=[{"role": "user", "content": "What's the latest on the Mars rover?"}],
)
print(response.content)Anthropic stresses two points when you build the augmentations. Tailor them to your specific use case, and give the LLM an easy, well-documented interface to them. The Model Context Protocol is one way to do this: with a simple client implementation, you can connect to a growing ecosystem of third-party tools. The quality of this building block limits every pattern built on top of it. A badly described tool hurts a single call and a multi-step agent alike.
Exam traps
Each one states something that sounds right. Open it to see what is actually true.
1.A business requirement that involves several steps always calls for an agentic system, because agents give the best results.Why is that wrong?
Anthropic recommends the simplest solution that works. For many applications, one optimized LLM call with retrieval and examples is enough, and agentic systems add latency and cost.
Covered in Start from the simplest thing that works
2.Any system that uses tools across several LLM calls is an agent.Why is that wrong?
What makes a system an agent is control. If code fixes the sequence, it is a workflow however many calls or tools it uses. It is an agent only when the LLM directs its own process and tool usage.
Covered in One family, two kinds of control
Sources
Every claim above is drawn from one of these pages, quoted as it was written on the date shown.
- 1.https://www.anthropic.com/engineering/building-effective-agentsSecondary source
“Workflows are systems where LLMs and tools are orchestrated through predefined code paths.”
↩︎ One family, two kinds of control“workflows offer predictability and consistency for well-defined tasks, whereas agents are the better option when flexibility and model-driven decision-making are needed at scale”
↩︎ One family, two kinds of control“Agentic systems often trade latency and cost for better task performance”
↩︎ Start from the simplest thing that works“Incorrect assumptions about what's under the hood are a common source of customer error.”
↩︎ Start from the simplest thing that works“The basic building block of agentic systems is an LLM enhanced with augmentations such as retrieval, tools, and memory.”
↩︎ The augmented LLM: the block everything is built from“tailoring these capabilities to your specific use case and ensuring they provide an easy, well-documented interface for your LLM”
↩︎ The augmented LLM: the block everything is built from“Workflows are systems where LLMs and tools are orchestrated through predefined code paths.”
↩︎ Key concept“For many applications, however, optimizing single LLM calls with retrieval and in-context examples is usually enough.”
↩︎ Exam trap 1“systems where LLMs dynamically direct their own processes and tool usage”
↩︎ Exam trap 2 - 2.https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practicesOfficial docs
“is still useful when you need to inspect intermediate outputs or enforce a specific pipeline structure”
↩︎ One family, two kinds of control“With adaptive thinking and subagent orchestration, Claude handles most multistep reasoning internally.”
↩︎ Start from the simplest thing that works - 3.
“Claude determines when to call a tool based on the user's request and the tool's description.”
↩︎ The augmented LLM: the block everything is built from