Architecture

Two ways to build the program

This lesson is not a ChatGPT feature, and it is not a product named “agent workflow.” It is the first real design choice you make when you write software that calls an LLM: does your code already know the steps, or is your code a loop that lets the model pick the next tool?

1. 1 · One callYour program: messages in, text out. Often enough.
2. 2 · WorkflowYour program already lists the steps. Control flow is in source.
3. 3 · AgentYour program is a while-loop. The model chooses the next tool until stop.

“Building your own agent” means writing that loop (later: wrapping it in a harness). A workflow is also something you build — it is just more prescribed.

Who owns control flow?

Anthropic’s definitions, used as the field’s split: a workflow orchestrates LLMs and tools through predefined code paths. An agent is a system where the LLM dynamically directs its own process and tool use. They call the pair agentic systems. Building effective agents

Same tools as lesson 0005. Architecture = who decides the next call.

# WORKFLOW — you already know the steps
a = llm("extract the order fields")
b = check_oven()                  # your code always does this next
c = llm("write the ticket", a, b)
return c

# AGENT — you do not know the steps
while steps < MAX:
    action = llm(messages, tools) # model: tool call or final text?
    if action is text:
        return action             # stop
    result = run(action)          # your code still runs the tool
    messages.append(result)       # paste back into RAM, loop

The muddy phrase “agent workflow”

People say it. Treat it as marketing fog. In this course:

• Workflow = predefined path in your code.
• Agent = model-directed loop in your code.
• ChatGPT / Claude as a user: you are talking to an agentic product someone else already built. This lesson is the program on the other side of the API.

Same idea, one kitchen example

If the flowchart is clear, you can skim this. It is only to make the two programs concrete.

check_oven()

stretch_dough()

top({ "tomato": true, "basil": true })

bake({ "seconds": 90 })

count_stock({ "item": "walnut" })

{ "handfuls": 3 }

check_oven()

{ "temp_c": 240 }

make_pizza({ "name": "walnut crumb" })

Metaphor only. The load-bearing picture is the flowchart and the two programs above.

Skill: name the architecture

Three requests into the same kitchen app. Watch whether your program is one call, a fixed sequence, or a loop.

Which one to write

Anthropic’s rule is not “build an agent.” It is: start with the simplest program that works, and add a loop only when a fixed path cannot name the steps. For many apps that is still one LLM call plus retrieval. Workflows buy predictability. Agents buy flexibility and spend latency and money. Same essay, “When (and when not) to use agents.”

An agent is a loop you must operate. Do not wrap a one-call job in that loop.

Mission skill: defend this choice in a design review.

If you chose a workflow

Anthropic names five common shapes of predefined path. They are still workflows — you drew them. An agent is what you write when even these shapes cannot name the steps in advance.

• Chaining Call 1 output becomes call 2 input (outline, then draft).
• Routing Classify, then send to a specialist prompt or model.
• Parallel Independent calls at once; or several votes, then merge.
• Orchestrator One LLM splits work; worker LLMs do pieces; you stitch.
• Evaluator Generate, critique, revise — a loop, but the critic step is in your path.

Do not memorise implementations tonight. The load-bearing fact: those five still have control flow in your code. Frameworks (LangChain, Agent SDKs) can hide whether you wrote a path or a loop — Anthropic’s advice is to see the calls first.

Check