What Are Agentic Workflows? Patterns, Examples, and When to Use Them

Table of Contents

What Is an Agentic Workflow?

An agentic workflow is a business process where an AI model does not just execute a fixed script but participates in deciding what happens next: iterating on its own output, choosing which tool to call, routing work based on what it reads, or looping until a result passes a check. The term describes a middle band on a spectrum. On one end sits classic automation, where every step is predetermined. On the other sits the fully autonomous agent, where the model plans and directs the whole job itself.

The two companies building the frontier models draw this line more carefully than most vendors selling on top of them. Anthropic's engineering guidance distinguishes workflows, where LLMs and tools run through predefined code paths, from agents, where the model dynamically directs its own process and tool usage. OpenAI's guide for builders defines agents as systems that independently accomplish tasks on your behalf, and is equally clear about the other side of the line: if a use case does not clearly need that autonomy, a deterministic solution may suffice.

The term has measured results behind it. In a widely cited March 2024 analysis, Andrew Ng summarized HumanEval coding benchmark results collected across research teams: GPT-3.5 scored 48.1% zero-shot and GPT-4 scored 67.0% zero-shot, while GPT-3.5 wrapped in an iterative agentic workflow reached as high as 95.1%. On that benchmark, the workflow around the model was worth more than the generation jump between models. That is a narrower claim than the vendor pitch version, and it is the honest one: workflow design can materially change what a given model achieves on a task with a checkable answer.

This post covers the architecture layer: what these systems are, the patterns they are built from, and how to decide what your process actually needs. If you already know the shape of your system and want deployment specifics, costs, and governance, that lives in our AI agent implementation guide.

Agentic vs Non-Agentic: Where the Line Actually Sits

The difference between an agentic and a non-agentic workflow is where model judgment enters the control flow. A non-agentic workflow may still use an LLM, and heavily. Extracting fields from an invoice, summarizing a call transcript, drafting a reply for human review: if the sequence of steps is fixed and the model just fills in one of them, that is classic automation with an LLM inside. It is often exactly the right design.

To keep the vocabulary straight, Anthropic's usage is the precise one: in a workflow, the topology is predefined in code, even when model decisions sit at some of its nodes; in an agent, the model chooses its own steps. "Agentic workflow" as commonly used covers that first category once model judgment starts doing real routing and checking work inside the fixed structure. Three capabilities mark the shift:

• Iteration. The model reviews and revises its own work against a standard instead of producing one pass. Ng's benchmark gains came overwhelmingly from this loop.
• Tool choice. The model selects which system to consult or act on (a calendar, a CRM, a search index) rather than being handed one.
• Dynamic routing. The model reads the input and decides which branch handles it, including the branch called "escalate to a human."

Notice what is not on that list: chat. A chatbot that answers questions in one pass is not an agentic workflow, no matter how good the answers are. And a system with no chat interface at all, silently triaging inbound documents every night, can be deeply agentic. The interface tells you nothing; the control flow tells you everything.

The Design Patterns That Matter

Production agentic systems are assembled from a small set of named patterns. Anthropic's guidance catalogs the workflow side; Ng's design-pattern series catalogs the agentic behaviors. Between them, six patterns cover the systems we scope and build:

1. Prompt chaining. Decompose the job into sequential steps, each model call consuming the previous output. A proposal pipeline that drafts, then tightens, then formats. Simple, debuggable, and the right default for linear work.
2. Routing. A classifier step reads the input and sends it down a specialized path: billing questions to the billing prompt and tooling, legal intake to the conflict-check flow, everything ambiguous to a person. Routing is where "the model decides" first pays for itself, provided the classifier's accuracy is validated against your real inputs before anything depends on it.
3. Parallelization. Run subtasks at the same time, or run the same task several times and vote. Useful when sections are independent (analyze twelve contracts) or when you want independent judgments to check each other (three reviews of one high-stakes output).
4. Orchestrator-workers. A lead model breaks the job into subtasks it could not have enumerated in advance and delegates each to a worker. This is the pattern for genuinely unpredictable scope, and the point on the spectrum where a workflow starts shading into an agent.
5. Evaluator-optimizer. One model generates, another grades against explicit criteria, and the loop repeats until the output passes or a round limit hits. This is Ng's reflection pattern made operational, and it is the pattern we reach for first in our own work, because it converts "the model sometimes gets it wrong" into "the system checks before it ships."
6. Planning with tools. The model writes a multistep plan, executes it with tool calls, and adjusts as results come back. Full agent territory. Powerful, and the hardest to make reliable, which is why both Anthropic and OpenAI tell builders to exhaust the simpler patterns first.

Beneath all six sits the foundation Anthropic calls the augmented LLM: a model extended with capabilities like retrieval, tools, and memory as the task requires. In our builds, one more layer is just as load-bearing: the eventing layer that tells the system something happened in your CRM, inbox, or practice platform in the first place. We wrote a plain-English breakdown of that layer in AI agent feeds and tasks explained.

When a Deterministic Workflow Beats an Agent

For a process whose steps can all be written down in advance, a deterministic workflow is usually cheaper, faster, and easier to audit than an agentic one. Both frontier labs say a version of this. Anthropic's guidance is to start with the simplest composition that works and add machinery only when it earns its place. OpenAI's is blunter: validate that the use case actually needs an agent, otherwise a deterministic solution may suffice.

We hold this position with our own systems, not just in advice. The booking pipeline on this site carries a visitor's funnel context from first click through calendar, email, and CRM across seven systems, and we deliberately built it as a deterministic workflow with closed vocabularies and validated boundaries, because booking a call has a knowable sequence and an unknowable sequence would add failure modes without adding value. The full architecture write-up is in how we built our booking funnel.

The honest decision variables:

• Can you enumerate the steps, and do the rules stay stable? If the sequence is knowable and the decision rules do not need constant maintenance, hardcode them. OpenAI's guide points agentic designs at the opposite cases: brittle rule sets, judgment over nuance, and heavy unstructured data.
• What does a wrong action cost? An agent that mislabels a document costs a correction. An agent that emails the wrong client costs trust. Autonomy should shrink as blast radius grows, with human approval gates at the irreversible steps.
• Can you check the work cheaply? Agentic loops need a grading function. If nobody can state what "correct" means, the loop cannot converge and the project is not ready.
• Does the volume justify the overhead? Iteration multiplies model calls, so the tolerance depends on latency requirements, throughput, and the model-call budget. Nightly batches absorb iteration easily; latency-sensitive real-time paths often cannot.

Agentic Workflow Examples in Business

The examples below are shapes we scope for mid-sized businesses, each mapped to its pattern:

• Inbound document triage (routing + evaluator). Contracts, invoices, and referrals arrive in one inbox. A classifier routes each to its extraction flow, an evaluator checks extracted fields against the source, and low-confidence items queue for a person. Agentic where it helps (routing, checking), deterministic where it matters (what happens to approved data).
• Exception handling in AP (routing + tool use). Three-way-match failures get investigated by a model that can look up the PO, the receipt, and the vendor history, then proposes a resolution with its reasoning attached or escalates with findings. The baseline matching stays rule-based, the agentic layer only touches the exceptions, and a person approves before anything posts.
• Lead qualification and enrichment (prompt chaining + tool use). New leads get researched across public sources, scored against your definition of qualified, and written into the CRM with a brief a human can challenge. A sensible early build because the blast radius is low and the manual cost it replaces is easy to measure.
• Support triage with escalation (routing + evaluator). Requests get classified by urgency and topic, drafts get generated for the routine tier, and anything matching escalation criteria goes straight to a person with context. The agentic version differs from an autoresponder in that it decides tier, and its deciding is graded.
• Retrieval-grounded assistance (augmented LLM + evaluation). The assistant on this site is instructed to answer from a curated document store, runs with a constrained tool set, and changes to it go through an evaluation script before they ship. Modest autonomy, deliberately: it is a bounded system, not a free agent, because it speaks to prospects in our name.

What these share: none is a general-purpose agent doing everything, and each is designed to put a human at the point of irreversibility. That design stance is why we build these as defined automation builds with explicit scope rather than open-ended agent platforms.

How to Choose: A Working Decision Framework

Work through these in order; each answer narrows the architecture:

1. Write the process as steps. If you can fully enumerate them, you want a deterministic workflow, possibly with LLM steps inside. Stop here; you will ship faster and sleep better.
2. Find the judgment points. Where does a person currently read something and decide? Those points are candidates for routing or evaluation patterns, one at a time.
3. Define "correct" for each judgment. If you can state it, an evaluator can grade it. The loop earns trust only after its judgments are measured against human ones; until then, keep the human in the loop.
4. Set the autonomy budget. List actions the system may take without approval and actions it must queue for one. Irreversible and outward-facing actions default to approval.
5. Choose one pattern to start, not a platform. The smallest pattern that addresses your highest-cost judgment point is the right first build. How to validate, instrument, and expand it in production is deployment work, covered in the implementation guide.

This sequencing is also roughly how an engagement with us runs: the process mapping happens in a Current State Assessment, and the architecture above becomes a scoped build with published pricing. If you are earlier than that, a free 30-minute AI Strategy Call is the right entry point, and this guide plus the implementation guide will make it a better conversation.

FAQs

What is an agentic workflow in simple terms? A business process where an AI model helps decide what happens next, rather than just filling in a step someone scripted. It might check and revise its own output, pick which system to consult, or route work down different paths based on what it reads.

What is the difference between agentic and non-agentic workflows? Who controls the sequence. In a non-agentic workflow the steps are fixed in code and a model may execute some of them; in an agentic workflow the model's output changes the path, through iteration, tool choice, or routing decisions.

Is ChatGPT an agentic AI? In its basic chat mode, no: it produces one response per prompt and controls no process. The product has grown agentic modes around that core, where it browses, runs multi-step research, and uses tools, and the models behind it power fully agentic systems built through OpenAI's APIs. So the honest answer is that ChatGPT is a suite, and how agentic it is depends on which mode is doing the work.

What is an example of an agentic workflow? Invoice exception handling is a clean one: standard invoices flow through rule-based matching untouched, and a model investigates only the mismatches, pulling the PO and vendor history, then resolving or escalating with its reasoning attached. The model directs the investigation; the rails around it stay fixed.

Are agentic workflows the same as AI agents? They overlap but are not identical. An agentic workflow adds model-directed decisions to a structured process; a full agent plans and directs an open-ended task end to end. In our build practice, the workflow band of that spectrum is where value ships reliably, and we reserve full autonomy for problems where fixed sequences genuinely cannot work, which matches the start-simple guidance both Anthropic and OpenAI publish.

How much does an agentic workflow cost to build? Our published pricing: a contained Defined Automation Build starts at $8,000, Focused Custom Automation runs $12,000 to $20,000, and typical delivery is 4 to 8 weeks. What drives the range, and the deployment decisions behind it, are covered in the implementation guide.

---

Sources

• Anthropic, "Building effective agents". The workflow/agent distinction and the pattern catalog this post builds on: prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer, and the augmented-LLM building block, with guidance to start simple.
• OpenAI, "A practical guide to building agents" (PDF). Defines agents as systems that independently accomplish tasks on a user's behalf, and advises validating that a use case needs one: otherwise a deterministic solution may suffice.
• Andrew Ng, "Agentic Design Patterns Part 1," The Batch, DeepLearning.AI (March 2024). The HumanEval results cited above (GPT-3.5 48.1% zero-shot, GPT-4 67.0% zero-shot, GPT-3.5 up to 95.1% in an agentic workflow) and the four agentic patterns: reflection, tool use, planning, multi-agent collaboration.