On this page
“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:
- A single, well-crafted model call with good context. You’d be surprised how often this is enough.
- A workflow that combines several model calls with ordinary code.
- 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:
- The path can’t be designed up front. The number and type of steps really depend on what the agent finds along the way.
- There’s a clear signal of success. The agent, or a test, can tell when the task is done correctly.
- 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.


