AI Agents · Deep dive

AI workflows vs AI agents: when you actually need an agent

Most business problems sold as 'agent' projects are better solved by a well-designed workflow. Here's how we decide, and the five patterns we use most.

By Max Chuchmai4 min read

On this page
  1. The distinction
  2. Start simple
  3. Five workflow patterns that cover most needs
  4. When an agent is the right call
  5. Building agents that behave
  6. How to frame your next AI project

“We want an AI agent” is one of the most common things we hear in first calls. When we dig into the problem, the right answer is usually not an agent. It’s a workflow that uses AI at specific steps. That isn’t a downgrade. Workflows are cheaper, faster, easier to test and much easier to trust.

This article explains the difference and how we decide between them. It builds on ideas Anthropic set out in its widely read engineering guide, Building effective agents, which matches what we see in client work.

The distinction

Both workflows and agents use large language models (LLMs). The difference is who controls the path.

  • A workflow follows steps you designed in advance. The model does specific jobs inside those steps, like classifying an email or drafting a summary, but the sequence is fixed in code.
  • An agent decides its own steps. It’s given a goal and a set of tools, and it chooses which tools to use, in what order, and when it’s done.

Agents are more flexible. They’re also less predictable, more expensive per task, and harder to test, because the same input can take a different path each time.

Start simple

Our rule is to use the simplest design that solves the problem, and only add complexity when it measurably improves the result. In order:

  1. A single, well-crafted model call with good context. You’d be surprised how often this is enough.
  2. A workflow that combines several model calls with ordinary code.
  3. An agent, only when the steps genuinely can’t be known in advance.

Five workflow patterns that cover most needs

1. Chaining

Break a task into fixed steps, where each model call works on the output of the last. Add code checks between steps.

Example: extract the key facts from a sales call transcript, check that required fields are present, then write the CRM update and follow-up email from those facts.

2. Routing

Classify the input first, then send it to a specialised path.

Example: sort inbound support emails into billing, technical and sales enquiries. Each type gets its own prompt, its own tools and its own escalation rules. Simple ones can go to a smaller, cheaper model.

3. Parallel steps

Run several independent model calls at once, then combine the results. Either split a task into parts, or ask the same question several times and compare answers.

Example: review a contract for payment terms, liability and data-protection clauses in parallel, with each check using its own focused prompt.

4. Orchestrator and workers

A central model breaks a task into subtasks that can’t be predicted in advance, hands them to worker calls, and combines the results. This is close to an agent, but still bounded.

Example: researching an account before a sales meeting. The orchestrator decides which sources are worth checking for this particular company, and workers summarise each one.

5. Review loops

One model call produces an output, another evaluates it against clear criteria and sends feedback, and the loop repeats until the output passes or a limit is reached.

Example: drafting personalised outreach where a reviewer step checks every claim against the research brief and rejects anything unsupported.

When an agent is the right call

Agents earn their place when three things are true:

  1. The path can’t be designed up front. The number and type of steps really depend on what the agent finds along the way.
  2. There’s a clear signal of success. The agent, or a test, can tell when the task is done correctly.
  3. Mistakes are cheap to catch. There’s a human checkpoint, a sandbox, or an undo before anything irreversible happens.

Good fits include research tasks, data investigation and coding inside a controlled environment. Poor fits include anything that sends money, sends external messages, or changes records of truth without review.

Building agents that behave

When we do build agents, a few rules make the difference between a demo and a system you can run:

  • Few, well-documented tools. Every tool gets a clear name, a description written for the model, and strict input validation. Most agent errors we debug are tool-design errors.
  • Hard limits. A maximum number of steps, a budget per task, and a timeout.
  • Permissions by default. Read access is broad; write access is narrow, and anything irreversible asks a human. See our article on human-in-the-loop design.
  • Full traces. Every step, tool call and decision is logged, so you can see why the agent did what it did.
  • Evaluation before release. A test set of real cases the agent must pass before any change goes live. We describe our approach in evaluating AI automations.

How to frame your next AI project

Instead of asking “where can we use an agent?”, ask:

  • Which process has the most repetitive, text-heavy work?
  • Can we write down the steps? If yes, build a workflow.
  • Where would a mistake be expensive? Put a human there.
  • How will we know it’s working? Define that before you build.

Answer those and the architecture usually picks itself.


We design and build AI workflows and agents for B2B operations teams. See our AI agents service.

Written by

Max Chuchmai

Founder & Managing Partner, CoderStein. System architecture, AI automation, and GTM engineering.

Follow on LinkedIn

Have a process you'd like AI to take over?

Book a 30-minute call. We'll tell you honestly whether it should be a workflow, an agent, or left alone.

Scope an automation