Agentic workflows are processes in which a large language model does more than answer once. It works through a task in steps: it plans, calls tools such as a CRM or a search index, checks its own output and revises it, and in the more autonomous versions decides for itself what to do next. That puts them on a spectrum. At one end is fixed automation, where every step is written in advance. At the other is an autonomous agent that chooses its own steps until the job is done. Most systems that work reliably in a business sit nearer the fixed end than the marketing suggests. This guide defines the terms using two primary sources, walks through the six common patterns with a business example for each, and covers when not to build one at all.
Workflow vs agent: the distinction that matters
Anthropic's engineering guide Building effective agents (December 2024) gives the clearest split. A workflow is a system where models and tools are orchestrated through "predefined code paths": a developer decided the order of steps, and the model fills in the judgement at each one. An agent is a system where the model directs its own process and tool use, deciding which step comes next and when it is finished. Anthropic groups both under the name agentic systems.
Andrew Ng popularised the term from a different angle. In a March 2024 letter in The Batch he contrasted asking a model for an answer in one pass with letting it iterate: outline, research, draft, review, revise. He named four design patterns for that iteration (reflection, tool use, planning and multi-agent collaboration) and reported that on the HumanEval coding benchmark, GPT-3.5 scored 48.1% in one pass and GPT-4 67.0%, while GPT-3.5 wrapped in an agent loop reached up to 95.1%. The point was that the loop around a model can matter more than which model you pick. Those numbers are from early 2024 models, so read them as a demonstration of the effect, not a current benchmark.
Put the two together and you get a usable definition. A workflow becomes agentic when a model's output decides something about the flow, whether that is which branch to take, whether a draft is good enough, or which tool to call next. The more of those decisions the model makes, the more agentic it is.
The spectrum, from fixed automation to autonomous agent
| Level | Who decides the next step | Example | Predictability | Cost per run |
|---|---|---|---|---|
| Fixed automation | Your rules | New Shopify order creates a row in the warehouse sheet | Identical every time | Almost nothing |
| One model call in a fixed flow | Your rules; the model fills one field | Classify a support email's language, then route by rule | High | Low |
| Chained or routed workflow | Your code, using the model's outputs | Extract invoice fields, validate in code, draft a payables note | High, if each step is checked | Low to medium |
| Orchestrated workflow | A model splits the work; code assembles it | Answer a 60-question security questionnaire from your policy library | Medium | Medium |
| Tool-using agent with limits | The model, within a fixed tool set and step cap | Resolve an order exception by checking order, carrier and stock systems | Lower; needs evals | Medium to high |
| Open-ended autonomous agent | The model, with broad tools | A coding agent working on a repository | Lowest | Highest |
Moving down the table buys flexibility and pays for it in predictability and money. Anthropic says this directly: agentic systems trade latency and cost for better task performance, and you should only make that trade when it pays.
The six patterns, with a business example for each
The first five are the workflow patterns Anthropic describes; the sixth is its agent pattern. The examples are ours, chosen from the kinds of jobs mid-sized companies bring us.
1. Prompt chaining
How it works: the task is split into fixed steps, each model call working on the output of the last, with checks in code between them. Business example: a supplier invoice arrives as a PDF. Step one extracts the fields as structured data. Code then checks that line items add up to the total and the supplier exists. Step two drafts the approval note for accounts payable only if the checks pass. Use it when a task splits cleanly into stages and you want to check each one. Watch for errors carrying forward: without the check between steps, a misread total becomes a confident wrong note.
2. Routing
How it works: a first step classifies the input and sends it to a specialised path, which may be a different prompt, a different model, or a person. Business example: inbound support email is sorted into order status, returns, product questions and complaints. Order status goes to a path that looks the order up; complaints go straight to a human. Anthropic also suggests routing easy questions to a smaller, cheaper model. Watch for misclassification. In a support agent we built for a Shopify Plus brand, the agent replies on its own only when classification and retrieval both clear confidence thresholds, and everything else goes to a person; it now resolves 64% of tickets that way (case study).
3. Parallelisation
How it works: several model calls run at once and their results are combined. Anthropic distinguishes sectioning, where independent parts of a task run side by side, from voting, where the same task runs several times and the answers are compared. Business example of sectioning: a contract review where separate calls check payment terms, liability caps and termination clauses against your playbook, while another screens the document for anything that should stop the process. Business example of voting: three independent checks on whether a product listing breaks marketplace rules, with a flag raised if any one says yes. Watch for cost, which multiplies with each parallel call.
4. Orchestrator-workers
How it works: a central model reads the task, decides how to break it up, hands the pieces to worker calls and assembles the result. Unlike parallelisation, the subtasks are not known in advance. Business example: answering a customer's security questionnaire. The orchestrator groups the questions, each worker drafts answers from the relevant policy documents, and the orchestrator assembles them and lists the questions it could not answer for a person to complete. Watch for the orchestrator inventing work. Cap the number of workers and log the plan it made so you can see why.
5. Evaluator-optimiser
How it works: one call produces a draft, a second call judges it against explicit criteria and sends feedback, and the loop repeats until the draft passes or a limit is hit. This is the reflection pattern in Ng's list. Business example: product descriptions written against a brand guide and a list of banned claims, where the evaluator checks tone, length and compliance and returns specific fixes. Use it when you can write down what good looks like. Watch for loops that never converge. Set a maximum number of rounds, and check that the evaluator agrees with your human reviewers before you trust it; our guide to calibrating an LLM judge covers how.
6. The tool-using agent loop
How it works: the model is given a goal and a set of tools, then repeats a cycle of choosing an action, calling a tool, reading the result and deciding what to do next, until it finishes or hits a stop condition. Business example: an operations agent handling an order exception. It looks the order up, checks the carrier's tracking, checks stock at a second warehouse, and proposes a fix (reship, refund or wait) for a person to approve with one click. Use it when the steps genuinely cannot be known in advance. Watch for compounding error: small per-step failure rates multiply over a long loop, which is why we split or gate long agents, as explained in when a multi-step AI agent fails in production.
When not to use an agentic workflow
Anthropic's first recommendation is to find the simplest solution that works and add complexity only when it clearly improves results. For many tasks, it notes, a single well-prompted model call with retrieval and a few examples is enough. We would go a step further: for a lot of business work, no model is needed at all.
- The input is already structured. If the data arrives in fields, rules route it faster, cheaper and identically every time.
- Nobody can define a correct answer. If you cannot write down what good output looks like, you cannot test an agent, and you will not know when it gets worse.
- A mistake is expensive and cannot be checked. Payments, legal commitments and medical decisions need a person in the path, at which point a simpler draft-and-approve workflow often does the job.
- The volume is tiny. Ten cases a week rarely justify the build and the monitoring.
- Your exception rate is low. If rules already handle nearly everything, keep them. Our guide to rules-based automation vs AI agents gives exception-rate thresholds for when the upgrade is worth it.
The best designs we see are hybrids: rules handle the predictable majority, and an agentic step takes only the cases the rules cannot.
What makes an agentic workflow safe to run in production
None of this is specific to one pattern. Each point has its own guide on this site, so here is the short version and where to read more.
- Evals before and after every change. A fixed set of real past cases with known right answers, run automatically, with a pass mark that blocks a release. What to measure is in AI agent eval metrics, and how to build the set from your own history is in building an eval set from support tickets.
- A person where it counts. Approval on anything hard to undo, and a path to a human when confidence is low. The four supervision patterns are in when an AI agent should stop and ask a human.
- Observability. A trace of every step: the prompt, the tool calls, the outputs and the cost, so you can explain any single decision after the fact. Anthropic lists showing the agent's planning steps as one of its three core principles. The rest of the stack is in the production AI agent stack.
- Cost caps. A maximum number of steps or rounds per run, token limits per call and a spend limit at the provider. Where the money really goes is in what an AI agent costs.
- Narrow, well-described tools. Give the agent the fewest tools that do the job, with least-privilege access, and document each one as carefully as a public API; Anthropic calls this the agent-computer interface. Treat anything the agent reads from outside as untrusted, as covered in our AI agent security framework.
Which pattern fits which job
A starting point, not a rule. Pick the lowest row on the spectrum that does the job.
| Job | Pattern | Why |
|---|---|---|
| Extract fields from invoices or purchase orders | Prompt chaining | Fixed stages, each checkable in code |
| Sort inbound email or tickets by intent | Routing | One classification decides the path |
| Draft replies to common support questions | Routing plus a draft for approval | Easy cases automated, hard ones to people |
| Review contracts against a playbook | Parallelisation (sectioning) | Independent clauses checked side by side |
| Flag risky listings or content | Parallelisation (voting) | Several checks lower the miss rate |
| Answer RFPs or security questionnaires | Orchestrator-workers | The breakdown depends on the document |
| Write on-brand product copy | Evaluator-optimiser | Clear criteria to check against |
| Resolve order or shipping exceptions | Tool-using agent, with approval | Next step depends on what each system returns |
| Research a prospect before a sales call | Tool-using agent, read-only | Open-ended search, low risk |
| Move an order into the ERP | No model; rules | Structured input, must be exact |
How agentic workflows get built
You can build the workflow patterns in an automation tool such as n8n, which has an AI Agent node and handles the plumbing; our guide to n8n templates covers which ones suit a business and what to fix before they go live. You can also write them directly against a model provider's API in your own code. Anthropic recommends starting with the API directly, and warns that frameworks can hide the prompts and responses you need to see when debugging. Whichever you choose, the patterns are the same, and so is the work of testing and monitoring them.
Getting one built
If you have a workflow in mind and want it in production, Gigabit Agents builds and deploys a production agent for a flat fee from $8,000 per agent; the fee covers build, deployment and 30 days of tuning. If the job is a single automation with an AI step, the AI Quick Win Sprint is $8,000 fixed over 3 weeks. If you are not sure which workflow should come first, the AI Transformation Sprint ($25,000, 2 weeks) maps your workflows, models the return and ends with one scoped, ready-to-build agent. And if the honest answer is that rules will do, we will tell you that too.
