CCAR-P 1.3 — Workflow, agent or augmented LLM

The ladder of autonomy

more autonomy, cost and latency ↓

Augmented LLMone call with retrieval, tools, memory
Workflowyour code fixes the path; Claude does each step
AgentClaude chooses the next step in a loop
Multi-agent systemseveral agents coordinated (see 1.4)

Each rung adds flexibility and adds cost, latency and unpredictability. Climb only as far as the task needs — and measure before each step up.

The definitions that everything rests on

Anthropic’s “Building effective agents” draws the line that this task statement uses. Workflows are systems where LLMs and tools are orchestrated through predefined code paths. Agents are systems where the LLM dynamically directs its own process and tool use, keeping control over how it accomplishes the task. Both are built from the same block: the augmented LLM, a model enhanced with retrieval, tools and memory that it can use actively — writing its own search queries, choosing tools, deciding what to remember.

The augmented LLM

Claudeone request

Retrievalsearch the knowledge base
Toolsquery or act on systems
Memorynotes kept across turns
Instructionssystem prompt, examples

The building block of every pattern. On its own it is often the whole solution: one call that retrieves what it needs, uses a tool or two and answers.

The five workflow patterns

When one call is not enough but the path can be written down, a workflow keeps control in your code. Anthropic describes five recurring shapes. Learn each one with the signal that points to it, because items often describe the signal and not the name.

Pattern	How it works	Choose it when	Enterprise example
Prompt chaining	Fixed sequence of calls; code gates between steps	The task splits cleanly into known steps	Draft a policy summary, check it against a rule list, then translate
Routing	Classify the input, send it to a specialised path	Distinct input types need different handling	Send billing, fraud and technical tickets to different prompts or models
Parallelization	Run calls at once: independent sections, or votes	Subtasks are independent, or you want several opinions	Screen a contract for five risk types at once; vote on a fraud flag
Orchestrator-workers	A model splits the task at run time and delegates	You cannot predict the subtasks in advance	Update every affected clause across a set of contracts
Evaluator-optimizer	One call drafts, another critiques, loop	Clear criteria exist and feedback measurably helps	Refine a regulator letter until it meets a style and content rubric

Two distinctions are worth holding onto. Parallelization and orchestrator-workers both fan out, but in parallelization your code fixed the subtasks beforehand, while the orchestrator decides them from the input. And routing is also a cost lever: the article notes that easy queries can go to a smaller, cheaper model and hard ones to a more capable one. Anthropic’s ticket-routing guide adds a practical twist — with more than about twenty categories, a hierarchy of classifiers can beat one flat classifier.

A routing workflow: code owns the pathpython

ROUTES = {
    "billing":   {"model": FAST_MODEL,    "system": BILLING_PROMPT},
    "fraud":     {"model": CAPABLE_MODEL, "system": FRAUD_PROMPT},
    "technical": {"model": FAST_MODEL,    "system": TECH_PROMPT},
}

def handle(ticket: str) -> str:
    # Step 1: one small call classifies the ticket.
    label = classify(ticket)            # returns "billing" | "fraud" | "technical"
    route = ROUTES.get(label)
    if route is None:
        return send_to_human(ticket)    # unknown label: fail safe, not creative

    # Step 2: the specialised prompt handles it. Code, not the model, chose this path.
    reply = client.messages.create(
        model=route["model"], max_tokens=1024,
        system=route["system"],
        messages=[{"role": "user", "content": ticket}],
    )
    return reply.content[0].text

When an agent is worth it

Anthropic’s guidance is to reach for agents on open-ended problems where the number of steps cannot be predicted and a fixed path cannot be hard-coded. An agent is, at heart, a model using tools in a loop and checking the results against the real environment at each step. That makes it powerful for work like resolving an IT incident or investigating an account anomaly, where each finding changes what to look at next.

The article is equally clear about the price. Agentic systems trade latency and cost for task performance; autonomy brings higher cost and the potential for compounding errors, so agents need extensive testing in sandboxed environments and appropriate guardrails. Two domains fit especially well: customer support, which combines conversation with actions such as looking up orders or issuing refunds, and coding, where automated tests give the agent objective feedback.

Choosing a pattern

What does the task need?

One judgement, known inputs
Augmented LLMsingle call, retrieval, tools
Known steps, fixed order
Workflowchain, route, parallelize, evaluate
Subtasks depend on input
Orchestrator and workersmodel plans, code bounds it
Open-ended, unknown steps
Agentloop, guardrails, checkpoints

Ask the questions in this order. Most enterprise processes stop at the first or second branch.

Workflow versus agent at a glance

Workflow

Path fixed in code; predictable and repeatable
Cost and latency known per request
Easy to test step by step and to audit
Breaks on inputs the designer did not foresee

Agent

Model chooses tools and steps at run time
Cost and latency vary per task
Needs sandbox testing, guardrails and stop rules
Adapts to inputs nobody anticipated

Worked example · An insurer’s three processes, three patterns

An insurer asks an architect to “add AI” to motor claims. Three processes are in scope: answering policyholders’ coverage questions, handling first notice of loss, and investigating suspected fraud rings.

Coverage questions → augmented LLM. One call retrieves the customer’s policy wording and answers with citations. The inputs are known and one judgement is needed. No workflow, no loop.
First notice of loss → workflow. The steps never change: extract details, check cover through the policy system, classify severity, route. A prompt chain with routing, plus code gates between steps, gives predictable cost and an audit trail.
Fraud investigation → agent. Each finding changes the next query — a shared phone number leads to another claim, which leads to a repair shop. An agent with read-only tools, a turn limit and a human investigator reviewing its findings fits the open-ended path.
Justify it in business terms. The two predictable processes carry most of the volume, so they get the cheap, auditable patterns. The agent’s higher per-case cost is justified by the value of the rare, complex cases it handles.

Takeaway: Pattern selection is per process, not per project. One enterprise engagement will usually contain several patterns side by side.

Worked example · A law firm’s translation that needed a critic

A law firm translates client advice letters into Spanish. Single-pass translations are accurate but lawyers keep correcting the same issues: defined terms rendered inconsistently and a tone that is too informal.

Recognise the signal. There are clear, checkable criteria (defined-term glossary, register), and lawyer feedback measurably improves the output. That is the evaluator-optimizer signal.
Design. One call translates; a second call checks the draft against the glossary and a tone rubric and returns specific problems; the translator revises. Code caps the loop at two rounds, then hands off to a lawyer either way.
Keep it a workflow. The loop is bounded and the roles are fixed by code. Nothing here needs the model to choose its own tools.

Takeaway: A loop does not make a system an agent. If your code defines who does what and when the loop ends, it is still a workflow — with a workflow’s predictability.

How you build it follows from the pattern

The article recommends starting with direct API calls — many patterns are a few lines of code — and adopting a framework only when you understand what it does underneath, since abstractions can hide the prompts and responses you need to debug. For agentic patterns, Anthropic offers three routes. With the Client SDK you call the API and implement the tool loop yourself. The Agent SDK is a Python and TypeScript library that runs the agent loop for you, with the same built-in tools, context management, hooks, subagents, permissions and MCP support as Claude Code. Managed Agents is a separate hosted API where Anthropic runs the agent and its sandbox, for long-running or asynchronous agents without your own infrastructure.

Pattern	Usual implementation	What the architect still owns
Augmented LLM	Messages API call with retrieval and tools	Context selection, output contract
Workflow	Your code calling the API step by step	Gates between steps, error paths, routing rules
Agent	Agent SDK, or a hand-written loop; Managed Agents if hosted	Tool permissions, stop conditions, human checkpoints

Traps the wrong answers are built from

Tempting but wrong	Do this instead
Defaulting to an agent because the stakeholder said “agent”	Match autonomy to the task: use an agent only when the steps cannot be predicted.
Forcing a rigid chain onto open-ended investigative work	Use orchestrator-workers or an agent where the next step depends on what was just found.
Calling any system with a loop an “agent”	If code fixes the roles and the exit, it is a workflow (for example, evaluator-optimizer).
Adopting a heavy framework before understanding the pattern	Start with direct API calls or a well-understood SDK, and know what it does underneath.
Shipping an agent without sandbox testing, guardrails or stop rules	Constrain tools and permissions, set limits and add human checkpoints before production.

You should now be able to

Define workflow, agent and augmented LLM, and explain how they relate.
Recognise the five workflow patterns from a scenario’s signals and name when each fits.
Decide when the unpredictability of a task justifies an agent’s extra cost and risk.
Assign different patterns to different processes within one engagement and justify each in business terms.
Choose between direct API calls, the Agent SDK and Managed Agents for an agentic design.

Workflow, agent or augmented LLM