Agentic AI Workflows:
Design Patterns and Production Implementation

Agentic vs. standard automation: when the distinction matters

A workflow is agentic when the AI model determines which steps to execute based on what it discovers during execution. In standard automation, the programmer decides every step in advance — the workflow executes the same sequence regardless of what the AI finds. In agentic automation, the workflow adapts to intermediate results.

This distinction only matters when the optimal sequence genuinely cannot be predetermined. For most business automation tasks — email classification, lead scoring, report generation, content repurposing — the same steps work for every input. Standard automation is the right choice: more reliable, cheaper, and fully debuggable. Agentic approaches add value only for tasks where what you do next depends on what you find.

The cost of agentic complexity

Agentic workflows are 5–20x more expensive per run than standard automation (more reasoning steps, more API calls), fail more often (70–80% vs. 90%+ success rates), are harder to debug (variable execution paths are harder to trace than fixed sequences), and require more sophisticated monitoring. Choose agentic only when the task genuinely requires adaptive decision-making. Never choose it just because it seems more impressive.

Three core agentic patterns that work reliably in production

Pattern 1: Tool-calling with bounded iteration

Give the AI a small, precise set of tools (3–5 maximum) and let it decide which to call and in what sequence, bounded by explicit limits. The key to reliability: tool descriptions must be precise about when to use and not use each tool. Vague descriptions produce arbitrary tool selection that cannot be debugged systematically.

{
  "name": "search_news",
  "description": "Search for recent news about a company or topic. USE FOR: events or announcements from the past 6 months, funding news, product launches. DO NOT USE FOR: general background info, company history, technical docs, information you can derive from what you already know.",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "Specific search query. Include company name and year. Example: 'Acme Corp Series B 2024'"
      },
      "max_results": {"type": "integer", "default": 3, "maximum": 5}
    },
    "required": ["query"]
  }
}

Pattern 2: Plan-then-execute

Before taking any actions, the agent explicitly generates a numbered plan: "To complete this task I need to: 1) Check Crunchbase for funding history 2) Search for recent news 3) Check LinkedIn for team size. Starting with step 1." This planning step forces the model to think through the complete task before diving in, reducing unproductive paths and missing important dimensions.

Add to your system prompt: "Before taking any actions, write a brief numbered plan of the steps you will take to complete this task. Then execute them in order."

Pattern 3: Self-verification loop

After generating output, the agent evaluates its own work against explicit criteria: "Review what you produced. Does it address every question in the original request? Is every factual claim supported by information you retrieved? If any requirement is unmet, correct it before returning." Self-verification catches errors that would otherwise require human review. Worth the additional LLM call for consequential outputs.

Implementing the ReAct loop in Python

The ReAct (Reason + Act) loop is the standard implementation pattern for agentic workflows. The agent reasons about what to do, calls a tool, observes the result, and continues until done or a limit is reached.

import openai, json, time
client = openai.OpenAI()

def run_agent(question, tools, tool_executor, system_prompt, max_steps=8):
    """Run an agentic ReAct loop with bounded iteration."""
    messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": question}
    ]
    
    start_time = time.time()
    MAX_SECONDS = 60  # Hard time limit
    
    for step in range(max_steps):
        if time.time() - start_time > MAX_SECONDS:
            return {"answer": "Time limit reached.", "steps": step, "complete": False}
        
        response = client.chat.completions.create(
            model="gpt-4o",  # Use capable model for agent reasoning
            messages=messages,
            tools=tools,
            tool_choice="auto",
            temperature=0.1,
            max_tokens=1000
        )
        
        message = response.choices[0].message
        messages.append(message.model_dump())
        
        # No tool calls = agent finished reasoning, has final answer
        if not message.tool_calls:
            return {
                "answer": message.content,
                "steps_taken": step + 1,
                "complete": True
            }
        
        # Execute each requested tool call
        for call in message.tool_calls:
            fn_name = call.function.name
            fn_args = json.loads(call.function.arguments)
            
            try:
                result = tool_executor(fn_name, fn_args)
                result_str = str(result)[:2000]  # Truncate long results
            except Exception as e:
                result_str = f"Tool error: {str(e)}"
            
            messages.append({
                "role": "tool",
                "tool_call_id": call.id,
                "content": result_str
            })
    
    # Reached max steps without completing
    return {
        "answer": "Task incomplete: maximum steps reached. Partial results may be in conversation.",
        "steps_taken": max_steps,
        "complete": False
    }

Using n8n's Agent node (no-code alternative)

n8n's visual Agent node implements the ReAct loop without code. Configure the LLM, system prompt, and attach tool nodes (HTTP Request, Code execution, other n8n nodes). The Agent node manages the loop automatically. This is the most accessible path to agentic workflows for practitioners who prefer visual tools, though it offers less control than direct Python implementation for debugging complex failures.

Production reliability engineering for agentic workflows

Use the most capable model available

GPT-4o and Claude 3.5 Sonnet significantly outperform smaller models for multi-step agent reasoning. The cost premium is justified — a research agent that succeeds 80% of the time with GPT-4o at $0.15/run is more valuable than one succeeding 55% with GPT-4o mini at $0.005/run, especially when failures require human intervention to recover from.

Log every step for debugging

For every agent run, log: which tools were called in what order, the parameters passed to each, each tool's response (truncated to 500 chars), the model's reasoning text between calls, total tokens consumed, and final outcome. Without this execution trace, debugging agentic failures is nearly impossible. Structure the log as an array of step objects — one per tool call — so you can replay any run to understand what happened.

Human-in-the-loop for consequential actions

For agents that take real-world actions (sending emails, updating records, making API calls that affect external systems), implement mandatory human approval before the consequential action. The agent can reason, research, and prepare — but a human approves the final action. This safeguard eliminates the most damaging class of agentic failures at the cost of one approval step per run.

Practical agentic workflow examples

Pre-meeting research agent

Given a contact name and meeting type, the agent determines which sources to check based on the company profile it discovers (Crunchbase for startups, SEC EDGAR for public companies, LinkedIn for all), searches each, follows relevant threads, and produces a structured briefing. Fixed automation cannot replicate this because the right sources genuinely depend on what the agent discovers about the company type. Production success rate: approximately 75–80% comprehensive, accurate briefs without human intervention.

Customer complaint investigation agent

Given a complaint email, the agent checks the customer's account history, retrieves recent support tickets, checks billing for anomalies, and looks for product changes correlating with the complaint date — selecting which of these to check based on the complaint content. A billing complaint triggers different checks than a feature request. The agent synthesises findings into a root cause assessment and resolution recommendation passed to a human support agent for execution.

Competitive intelligence agent

Given a competitor name, the agent visits their pricing page, checks job postings to infer strategic direction from hiring patterns, searches for recent news, and reads significant announcements in full. The agent decides which signals are worth reporting — trivial updates are filtered out, significant changes are flagged with context. Runs weekly; only posts to Slack when it finds genuinely notable changes rather than generating noise.

Frequently asked questions