top of page

Agents vs. Workflows: Not Everything Called an "Agent" Is One

carocsteads
3 days ago
4 min read

Agents, from the ground up · Part 2 of 7. In Part 1 we defined an agent as a model + a loop + tools. Now for the distinction that cuts through most of the hype.

Open any product page today and everything is an "agent." The email summarizer is an agent. The chatbot is an agent. The thing that renames your files is an agent. Most of them aren't, and that's fine. There are two fundamentally different ways to build with LLMs, and knowing which one you're looking at changes how you design it, test it, and trust it.

A workflow: you decide the steps

A workflow is a set of LLM calls wired together by your code along a path you fixed in advance. For example: summarize the document, then translate the summary, then email it. The order is hard-coded. The model fills in each box, but it never chooses what comes next.

summary     = llm("Summarize this report", report)
translation = llm("Translate to Spanish", summary)
send_email(to=team, body=translation)

Your code is the boss. The model is a very talented employee who only ever answers the question in front of it.

An agent: the model decides the steps

An agent directs its own process. You hand it a goal and a set of tools, and it decides at runtime which tools to use, in what order, and when it's finished. Give it "handle this support ticket" and it might search the docs, look up the order, notice the order shipped to the wrong address, draft a reply, or escalate to a human. It chooses the path. You couldn't have drawn that flowchart ahead of time, because the path depends on what it discovers along the way.

Workflow = a fixed path you wrote. Agent = a path the model decides as it goes.

It's a spectrum, not a switch

In practice there's a ladder of autonomy between "one LLM call" and "fully autonomous agent." Each rung gives the model a bit more say:

  1. Single call. One prompt, one answer. No loop at all.

  2. Chain. Fixed steps in sequence, like the summarize/translate/email example above.

  3. Router. The model classifies the input ("billing, technical, or refund?") and your code sends it down a predefined branch. The model picks the lane, but you built every lane.

  4. Orchestrator-workers. A model breaks a task into pieces and hands them out. The split is dynamic, but each piece is bounded.

  5. Agent. The model runs the loop itself: think, act, observe, repeat, until it decides it's done.

When someone says "we built an agent," it's worth asking which rung they mean.

The same problem, built both ways

Take a support ticket that says "My card was charged twice."

As a workflow: classify the ticket as billing, fetch the last five transactions, ask the model "is there a duplicate charge?", and if yes, draft a refund reply for a human to approve. Four boxes, always in that order. It's fast, cheap, and every run looks the same.

As an agent: give the model tools for search_transactions, lookup_customer, read_policy, and draft_reply. It might discover the "duplicate" is actually a pre-authorization hold, read the policy on holds, and explain that instead. That's more flexible, but it's also less predictable, slower, and it touched more data along the way.

So which should you build?

They trade the same thing in both directions:

  • Workflows are predictable, cheap, fast, and easy to debug, because you can test each box on its own. But they're rigid. Anything you didn't anticipate falls through the cracks.

  • Agents are flexible and handle the unexpected gracefully. But they cost more tokens, run longer, behave less predictably, and are much harder to reason about when something goes wrong.

The honest rule: use the simplest thing that works. If you know the steps in advance, a workflow is the better design. Don't reach for an agent just because it's the exciting word. Most real "agent" products are mostly workflows with one genuinely agentic step in the middle, and that's usually the right architecture.

A quick "do I need an agent?" checklist

  • Can you write the steps down before you start? Then use a workflow.

  • Does the right next step depend on what you find along the way? Then it may need an agent.

  • Is a wrong action expensive or irreversible (money, deletions, emails)? Then use a workflow, or an agent with a human approval gate.

  • Can you verify the outcome automatically (tests pass, the file exists, the numbers reconcile)? That makes an agent much safer to use.

Why this matters if you test AI systems

This distinction changes how you test. A workflow can be tested like normal software: each box gets its own inputs and expected outputs. An agent can't be fully tested by its steps, because the steps change from run to run. Instead you test the outcome (did it end up in a correct state?) and the boundaries (did it ever call a tool it shouldn't have, touch data it shouldn't have, or loop forever?). That's a big part of the security work on FinBot: agents are allowed to choose their path, but the walls around that path have to hold no matter what they choose.

Next up, Part 3: The anatomy of an agent. The five ingredients every agent runs on, and why a "specialist agent" isn't a smarter AI at all.

Enjoyed this? Get every new post by email with the Subscribe to the blog form at the bottom of this page. You can also sign up as a site member (top of the page) to follow along.

Agents, from the ground up · © Carolina Steadham

Comments


Subscribe to the blog

© 2026 by Carolina Steadham. All rights reserved.

bottom of page