AI Agent Workflow Design: Patterns That Ship in Production

Most AI agents don't fail because the model picked was wrong or the prompt was weak. They fail because nobody designed the workflow they live inside.

A workflow is the shape that turns a one-shot LLM call into a reliable system. It decides when the agent runs, what tools it can use, when it stops, when it escalates, when it retries. Get the workflow right and a Claude Haiku 4.5 agent ships production-quality output. Get it wrong and a Claude Opus 4.8 agent fails on edge cases nobody anticipated.

This guide covers the eight workflow patterns that ship in production, the three that don't, and the decision tree for picking the right shape for your job.

What an AI agent workflow actually is

An AI agent workflow is a defined sequence of actions an agent takes to accomplish a task. Read input, call tools, make decisions, produce output. Unlike traditional workflow automation (Zapier, Make), agent workflows include non-deterministic decision-making steps where the agent chooses what to do next based on context.

The workflow is everything around the model call:

• The trigger that starts the agent (a schedule, an event, a manual run)
• The inputs the agent receives
• The tools the agent can call
• The branching logic that decides what happens next
• The error handling that catches failures and decides whether to retry or escalate
• The success criteria that determine when the workflow is done
• The output the agent produces

Every production agent has a workflow, whether or not the team designed it explicitly. The teams that designed it ship reliably. The teams that didn't ship and then spend weeks debugging.

The eight workflow patterns that ship in production

Most production agents combine 2–4 of these patterns. Knowing which patterns fit which jobs is the architectural decision that determines success.

1. Linear pipeline. The agent executes a fixed sequence of steps. Read input → call tool A → call tool B → produce output. No branching, no loops. The simplest pattern and the right default for most well-defined tasks.

Best for: ticket classification, data extraction, content drafting against a template. Anything where the steps are known and the output shape is predictable.

2. Conditional branching. The agent decides between paths based on context. Read input → classify it → if category A run path A, if category B run path B, if category C escalate to a human.

Best for: support triage, lead qualification, content routing — workflows where different inputs need different processing.

3. Loop until done. The agent retries with adjusted inputs until a success condition is met or a retry limit is hit. Generate output → check against the criterion → if it doesn't meet, refine the prompt and try again.

Best for: tasks where the first attempt is often wrong but iterative refinement converges — code generation, creative writing, structured data extraction with strict format requirements.

Critical caveat: every "loop until done" workflow needs a max-iteration cap. Without one, you have a runaway-cost failure mode. Our guardrails article covers the seven controls every production agent needs, with budget caps at the top of the list.

4. Parallel exploration. Multiple agents try different approaches in parallel; a coordinator picks the best. Spawn four agents with different framings of the same task → evaluate their outputs → return the winner.

Best for: research synthesis, algorithm exploration, creative brainstorming. Tasks where the variance across approaches is high enough to justify the parallel spend. Cost is the main constraint — N agents run N times the tokens of one.

5. Supervisor-worker. One agent acts as a dispatcher; specialist agents do the work. The supervisor decides what subtasks are needed → assigns each to a specialist → aggregates the results.

Best for: complex workflows that need specialisation (code writer + reviewer, content drafter + fact-checker). The multi-agent AI guide covers when this pattern actually wins vs over-engineering.

6. Human-in-the-loop. The agent acts up to a defined boundary, then waits for human approval before proceeding. Draft the email → wait for approval → send. Generate the contract → wait for review → file.

Best for: any workflow where the agent's action is irreversible or high-stakes — sending external communications, charging cards, executing trades, deploying code to production. The approval gate is the safety net that lets you ship agents into roles you wouldn't trust fully autonomously.

7. Schedule-triggered. The agent runs on a cron, every hour, every day, every Monday at 9 AM. Wakes up, checks if there's work, executes, sleeps.

Best for: recurring tasks where the trigger is time, not an event — daily reports, weekly digests, periodic data refreshes, monitoring checks. The simplest reliable shape for "do this every X" workflows.

8. Event-triggered. The agent runs when an external event fires, a webhook arrives, an email lands, a row is added to a database. Reactive rather than scheduled.

Best for: real-time response patterns — incoming support tickets, sales lead notifications, system alerts. Fast and efficient when the event volume is predictable; needs rate limiting when it isn't (webhook storms are a real failure mode).

How to design a workflow that actually works

Five steps that turn "we want an AI agent for X" into a workflow that ships.

Step 1: Write the workflow as if a junior employee would execute it.

Every step, every decision, every escalation path. The places where the junior would say "check with manager" are your approval gates. The places where they'd "try another approach" are your retry loops. The places where they'd "route this to the right team" are your conditional branches.

This sounds basic. It's the step that separates production-ready workflows from prototypes that break in week two. Most teams skip it because it feels like overhead. It isn't.

Step 2: Map each step to either a tool call or an agent decision.

Tool calls are deterministic — given the same input, they always produce the same output. Database queries, API calls, file reads. Agent decisions are non-deterministic, the agent uses judgement based on context.

The honest rule: use deterministic steps wherever you can. Every agent decision is a place the workflow can fail in non-obvious ways. Reserve agent decisions for the parts that genuinely require judgement.

Step 3: Define the success criterion explicitly.

"The customer-support ticket got a response" isn't a criterion. "The response addresses the customer's question, uses our brand voice, and includes the next action they need to take" is. Without an explicit criterion, your agent will produce outputs that "work" by no measure anyone can articulate.

The best place to put the criterion: in the agent's prompt and in your test set. The agent gets evaluated against the same standard at training and deploy time.

Step 4: Build the test set before the agent.

Five to ten real-world examples with expected outputs. Run them against the workflow on every deploy. Even informal testing prevents the "looked good in demo, broken in production" problem that catches most teams once.

Step 5: Instrument from day one.

Logs on every step — prompt, model response, tools called, latency, success or failure. Ship those logs somewhere queryable. Adding observability after a failure means weeks of operating blind. Our observability guide covers what to instrument and how.

The three workflow patterns that don't ship

Three patterns we've watched teams build, ship, and regret:

Anti-pattern 1: Workflow with no clear success metric.

The agent runs. It produces output. Nobody can agree whether the output is good. Without a success metric, you can't iterate the prompt, you can't test the deploy, you can't justify the cost. The fix is editorial, not technical: write the metric before you build.

Anti-pattern 2: Workflow with no budget cap.

A multi-agent loop, a "retry until success" pattern, or an event-triggered workflow with no rate limiting — any of these can run away in ways that cost real money. We've seen single overnight runs burn $400+ because nobody set a per-day cap. Add the budget cap before the first deploy. Always.

Anti-pattern 3: Workflow treated as one-time setup.

Production agents need ongoing tuning. The prompts drift as the model is updated. The edge cases multiply as volume grows. The handoff protocols decay as new inputs surface. Teams that ship a workflow and walk away find it broken in month three. Plan for the maintenance from day one.

The best AI agent workflow platforms

Six platforms ship workflows as their core offering, each with different strengths:

• n8n — visual workflow builder, 400+ integrations, self-hostable. Best for technical teams that want a clean diagram of their workflow logic plus deep integration with their other tools. Free open-source self-hosted, $24/month cloud.
• Lindy — no-code workflow templates that ship working in under an hour. Best for non-developers building sales follow-up, support triage, or meeting prep workflows. From $49/month.
• Paperclip — orchestration layer for multi-agent workflows. Best when you need supervisor-worker patterns with budget caps and approval gates baked in. MIT, self-hostable.
• Relevance AI — visual workflow editor sitting between Lindy and n8n on the technical spectrum. Best for skilled operators who want more control than no-code allows. From $19/month.
• Stack AI — strongest for document-Q&A workflows with RAG pipelines. From $199/month.
• Claude Code — code-based workflows for developers. Best when you want full control and you're comfortable writing the workflow logic. Bundled with Claude Pro ($20/month).

The 2026 shortlist covers all 27 platforms with the full decision matrix.

A worked example: customer support deflection

What a real production workflow looks like in practice. The job: handle inbound support tickets, deflect the simple ones to AI, escalate complex cases to humans.

Pattern combination: event-triggered (incoming ticket) + conditional branching (deflect vs escalate) + human-in-the-loop (approval on edge cases).

The workflow:

1. Trigger: ticket lands in Intercom, webhook fires
2. Classify: agent reads the ticket, classifies it by category (billing, technical, account, complex) and confidence level
3. Branch on confidence:
   • High confidence + simple category → agent drafts response, sends automatically
   • High confidence + complex category → agent drafts response, routes to human queue for review
   • Low confidence → agent escalates immediately with its best guess as context for the human
4. Tools available: knowledge base search, account lookup, order status, internal docs
5. Budget cap: $50/day across the whole workflow
6. Observability: every classification, every tool call, every response logged to LangSmith
7. Test set: 20 real historical tickets covering each category, run before every deploy

Cost on Claude Sonnet 4.6 at 1,000 tickets/day: roughly $40–60/month in tokens. Quality: typically 70–80% deflection on tier-1 volume after two weeks of tuning.

This is a five-pattern workflow (event + branch + retry + human-in-the-loop + budget). Most production agents look like this, not one pattern, but a small composition that fits the job.

What to actually do

Workflow design is the under-appreciated half of building agents. The model gets the attention; the prompt gets the iteration; the workflow gets built by accident.

Teams that explicitly design the workflow ship reliable agents in days. Teams that don't ship something that works in the demo and breaks in week three.

The eight patterns above cover ~90% of production agent workflows. Most jobs combine two or three of them. The decision tree is:

• What triggers the workflow? (schedule, event, manual)
• What's the basic shape? (linear, branching, loop, parallel)
• Where does human judgement come in? (approval gates, escalations)
• What's the success metric? (write it down before building)
• What's the budget cap? (always)

Get those five questions answered before opening any platform, and the build itself is straightforward.

What to read next

The AI agent orchestration guide covers the layer above workflow — managing multiple workflows, enforcing budgets across them, handling cross-workflow handoffs. Multi-agent AI covers when supervisor-worker patterns actually beat single-agent setups. How to create an AI agent walks through the four real paths from no-code to fully custom. The observability guide covers what to instrument so workflow failures are debuggable.

If you're stuck deciding between platforms for a workflow, the picker is a five-question version of the question.