An AI agent decides what to do next based on the situation. A workflow follows a predetermined path. Most production AI systems should be workflows, not agents. Here’s why and when to break that rule.

The difference

Workflow (deterministic):

Input → Step 1 → Step 2 → Step 3 → Output

Every input follows the same path. Predictable, testable, debuggable.

Agent (autonomous):

Input → LLM decides → Action → LLM evaluates → Next action → ... → Output

The LLM decides what to do at each step. Flexible but unpredictable.

When to use workflows

Use a workflow when the steps are known in advance:

async def summarize_and_translate(document, target_language):
    # Step 1: Always summarize first
    summary = await call_llm(f"Summarize: {document}")
    
    # Step 2: Always translate second
    translated = await call_llm(f"Translate to {target_language}: {summary}")
    
    # Step 3: Always format third
    formatted = await call_llm(f"Format as bullet points: {translated}")
    
    return formatted

Advantages:

• Predictable cost (fixed number of LLM calls)
• Easy to test and debug
• Consistent latency
• No infinite loops
• Simple monitoring

Use for: Content pipelines, data processing, classification, summarization, translation, formatting.

When to use agents

Use an agent when the steps depend on the results:

async def debug_code(error_message, codebase):
    # Agent decides what to do based on the error
    tools = [read_file, search_code, run_tests, edit_file]
    
    return await agent_loop(
        task=f"Fix this error: {error_message}",
        tools=tools,
        max_steps=15,
    )

Advantages:

• Handles novel situations
• Can recover from failures by trying different approaches
• Adapts to unexpected inputs

Use for: Coding tasks, research, complex problem-solving, tasks where the path isn’t known in advance.

The hybrid approach (recommended)

Most production systems combine both:

async def handle_support_ticket(ticket):
    # WORKFLOW: Fixed classification step
    category = await classify(ticket)  # Always runs
    
    if category == "simple_question":
        # WORKFLOW: Direct answer
        return await answer_from_faq(ticket)
    
    elif category == "bug_report":
        # AGENT: Needs investigation
        return await debug_agent(ticket)
    
    elif category == "feature_request":
        # WORKFLOW: Fixed response
        return await create_jira_ticket(ticket)

The workflow handles routing (cheap, fast, predictable). The agent handles complex cases (expensive, slow, but necessary).

Cost comparison

Approach	LLM calls	Cost per request	Predictability
Workflow (3 steps)	3	~$0.01	✅ Fixed
Simple agent (5-10 steps)	5-10	~$0.03-0.10	⚠️ Variable
Complex agent (10-30 steps)	10-30	~$0.10-1.00	❌ Unpredictable

See our cost optimization guide and when NOT to use agents for keeping costs under control.

Decision framework

Are the steps always the same?          → Workflow
Does the next step depend on results?   → Agent
Can you hardcode the logic?             → Workflow
Does it need to handle novel situations? → Agent
Is cost predictability important?       → Workflow
Is flexibility more important?          → Agent

Default to workflows. Only use agents when the task genuinely requires autonomous decision-making. Most “agent” use cases are actually workflows with an LLM in each step.

Related: How to Build Multi-Agent Systems · Agent Orchestration Patterns · When NOT to Use AI Agents · Best AI Agent Frameworks · How to Debug AI Agents