Why Most Agents Don't Need to Be Agents

Hot take: 80% of "AI agent" projects should be workflows with LLM-enhanced steps, not autonomous agents.

I see this pattern constantly:

Company wants to automate a business process. They hear "AI agents are the future!" So they build an autonomous agent with tool access, reasoning loops, and decision-making capabilities.

Then they discover:

• It's unpredictable (makes different choices each run)
• It's slow (reasoning takes time)
• It's expensive (lots of LLM calls)
• It's hard to debug (why did it do that?)
• It gets stuck in loops
• Sometimes it just... doesn't work

Meanwhile: A simple workflow with LLM-powered steps would have been faster, cheaper, and more reliable.

Let me explain the difference and save you months of frustration.

What's an Autonomous Agent?

An autonomous agent is given a goal and figures out how to achieve it.

Characteristics:

• Decides what tools to use
• Plans multi-step actions
• Adapts based on results
• Runs in loops until goal is achieved

Example:

Goal: "Research competitor pricing and create a summary"

Agent thinks: "I should search their website"
→ Uses search tool
→ Finds pricing page
→ Thinks: "I should extract the prices"
→ Uses scraping tool
→ Thinks: "I should compare to our prices"
→ Uses database tool
→ Thinks: "I should create a summary"
→ Generates summary
→ Done

Looks impressive, right?

Problems:

• 6 LLM calls (expensive)
• 15+ seconds (slow)
• Might take different paths each time (non-deterministic)
• Could get stuck in loops
• Hard to debug when it fails

What's a Workflow with LLM Steps?

A workflow is a predefined sequence where specific steps use LLMs.

Characteristics:

• Deterministic flow (same steps every time)
• LLM used only where needed
• Traditional code for structure
• Predictable, fast, debuggable

Same task as workflow:

def research_competitor_pricing(competitor_name):
    # Step 1: Deterministic - Search for website
    website = search_engine.find_official_site(competitor_name)

    # Step 2: Deterministic - Fetch pricing page
    pricing_html = scrape_page(website + "/pricing")

    # Step 3: LLM-enhanced - Extract structured data
    pricing_data = llm.extract_structured_data(
        html=pricing_html,
        schema=PricingSchema
    )

    # Step 4: Deterministic - Load our pricing
    our_pricing = database.get_our_pricing()

    # Step 5: LLM-enhanced - Generate comparison
    summary = llm.generate_summary(
        prompt="Compare these pricing structures",
        competitor=pricing_data,
        ours=our_pricing
    )

    return summary

Result:

• 2 LLM calls (cheaper)
• 5 seconds (faster)
• Same path every time (predictable)
• Clear execution trace (debuggable)
• No loops (won't get stuck)

When You Actually Need an Autonomous Agent

Don't get me wrong — agents have their place.

Use Autonomous Agents When:

1. The path to the goal is truly unknown

Example: Research Assistant

Task: "Find out why our sales dropped last quarter"

The agent needs to:

• Explore different data sources
• Follow leads based on what it finds
• Adapt its investigation dynamically

There's no predefined path. The agent must figure it out.

2. High variability in task requirements

Example: Personal Assistant

User requests:

• "Schedule a meeting next week"
• "Find a good Italian restaurant nearby"
• "Summarize these emails and draft responses"

Each task requires completely different tools and approaches. An agent can handle this variety.

3. User-driven exploration

Example: Data Analysis Agent

User: "Show me sales trends" Agent: [Shows chart] User: "Break that down by region" Agent: [Generates new analysis] User: "What's driving the spike in Q3?" Agent: [Investigates and explains]

The conversation is exploratory. An agent follows where the user leads.

4. Truly autonomous operation required

Example: Monitoring Agent

The agent runs 24/7, monitoring systems and taking action when it detects issues. No human guidance.

When You DON'T Need an Autonomous Agent

Use Workflows When:

1. The process is well-defined

Example: Invoice Processing

1. Extract data from PDF
2. Validate required fields
3. Match to purchase order
4. Approve if match
5. Send to accounting system

This is the same every time. Why make an agent "figure it out"?

2. Reliability is critical

Example: Payment Processing

You can't have an agent "decide" how to process a payment. The steps must be deterministic and auditable.

Workflow: 99.9% reliable Agent: 90-95% reliable (at best)

3. Cost matters

Agent approach (5 LLM calls per execution):

• 10,000 executions/day
• 5 calls × $0.01 = $0.05 per execution
• 10,000 × $0.05 = $500/day
• = $15,000/month

Workflow approach (1 LLM call per execution):

• 10,000 executions/day
• 1 call × $0.01 = $0.01 per execution
• 10,000 × $0.01 = $100/day
• = $3,000/month

Savings: $12,000/month ($144K/year)

4. Speed matters

Agent: 10-30 seconds (multiple reasoning loops) Workflow: 2-5 seconds (direct execution)

When speed matters: Real-time user interactions, high-volume processing.

5. You need to explain what happened

Agent: "The AI decided to do X, then Y, then Z" Workflow: "Step 1 executed, Step 2 executed, Step 3 failed at line 47 because..."

Which one can you debug? Which one can you explain to regulators?

The Pattern: Job Runner + LLM Steps

Here's the pattern that works for 80% of "agent" use cases:

Architecture:

class JobRunner:
    def execute(self, job_type, params):
        # Deterministic job selection
        job = self.get_job(job_type)

        # Execute steps in order
        for step in job.steps:
            if step.type == "deterministic":
                result = step.execute(params)
            elif step.type == "llm_enhanced":
                result = self.llm_step(step, params)

            params.update(result)

        return params

    def llm_step(self, step, context):
        # LLM used for specific capability
        prompt = step.prompt_template.format(**context)
        result = llm.generate(prompt)
        return step.parse_result(result)

Example: Customer Onboarding

onboarding_job = Job([
    Step("validate_email", type="deterministic"),
    Step("check_existing_account", type="deterministic"),
    Step("classify_business_type", type="llm_enhanced"),  # LLM here
    Step("create_account", type="deterministic"),
    Step("generate_welcome_email", type="llm_enhanced"),  # LLM here
    Step("send_email", type="deterministic"),
])

Benefits:

• Structure is deterministic (reliable)
• LLM used only where needed (cost-effective)
• Clear execution path (debuggable)
• Fast (no unnecessary reasoning)
• Testable (can verify each step)

Real-World Comparison

Let's compare approaches for a real use case: Content Moderation

Autonomous Agent Approach

agent = Agent(
    goal="Moderate this user comment",
    tools=[
        check_profanity,
        check_spam,
        check_toxicity,
        check_pii,
        flag_for_review,
        approve_content,
        reject_content
    ]
)

result = agent.run(comment)

What happens:

• Agent reasons about which checks to run
• Agent decides order of checks
• Agent interprets results
• Agent decides action

Time: 8-15 seconds Cost: $0.03-0.05 per comment Reliability: 92%

Workflow Approach

def moderate_content(comment):
    # Step 1: Quick deterministic checks
    if contains_profanity(comment):
        return "rejected", "profanity"

    if is_spam_pattern(comment):
        return "rejected", "spam"

    # Step 2: LLM-powered nuanced check
    toxicity_result = llm.analyze_toxicity(comment)

    if toxicity_result.score > 0.8:
        return "rejected", "toxic"

    if toxicity_result.score > 0.5:
        flag_for_human_review(comment)
        return "pending", "borderline"

    # Step 3: Approve
    return "approved", None

What happens:

• Deterministic checks run first (fast, cheap)
• LLM used only for nuanced cases
• Clear decision tree
• Predictable outcomes

Time: 1-3 seconds Cost: $0.005-0.01 per comment Reliability: 98%

Winner: Workflow (faster, cheaper, more reliable)

When to Upgrade from Workflow to Agent

Start with a workflow. Upgrade to an agent only when you hit these signs:

Sign #1: You're constantly adding new IF/ELSE branches

• Workflow is becoming unmaintainably complex
• New edge cases every week

Sign #2: Users want flexibility

• "Can it do X?" "Can it also do Y?"
• Requirements are exploratory, not fixed

Sign #3: The task requires genuine planning

• Multi-step reasoning where steps depend on previous results
• No clear "right" sequence of actions

Sign #4: Cost/speed tradeoffs favor flexibility

• Accuracy is more important than speed
• Budget allows for higher LLM costs

Common Mistakes

Mistake #1: Building an Agent First

Wrong approach: "Let's build an autonomous agent!"

Right approach: "Let's build a workflow. If it gets too complex, we'll consider an agent."

Start simple. Add complexity only when needed.

Mistake #2: Using Agents for High-Volume Tasks

Wrong: Agent processes 100,000 tasks/day

Right: Workflow processes 100,000 tasks/day, agent handles escalations

Why: Agent costs 10x more per execution. At high volume, that's unsustainable.

Mistake #3: Ignoring Determinism

Wrong: "Non-determinism is fine, it's AI!"

Right: "We need predictable behavior for production systems"

When non-determinism is OK: Creative tasks, exploration, user-facing chat When it's not OK: Financial transactions, compliance workflows, high-volume processing

Mistake #4: No Fallback

Wrong: Agent fails → entire workflow stops

Right: Agent fails → fallback to human or simpler workflow

Always have a fallback for agent failures.

The Bottom Line

Most "agent" use cases are actually workflows with LLM-enhanced steps.

Autonomous agents are powerful but:

• Expensive (many LLM calls)
• Slow (reasoning takes time)
• Unpredictable (different paths each time)
• Hard to debug (complex decision chains)

Workflows with LLM steps are:

• Cheaper (fewer LLM calls)
• Faster (direct execution)
• Predictable (same path every time)
• Debuggable (clear execution trace)

Use agents when: The path is truly unknown, variability is high, or exploration is the goal.

Use workflows when: The process is known, reliability matters, or you're processing high volumes.

Start simple: Build a workflow. Upgrade to an agent only if you actually need the autonomy.

Getting Started

Quick assessment:

For your use case, ask:

1. Can I define the steps in advance? → Workflow
2. Does the path change based on findings? → Maybe agent
3. Do I need 99%+ reliability? → Workflow
4. Is cost a concern at scale? → Workflow
5. Do I need to explain decisions? → Workflow

Rule of thumb: If you can write it as a flowchart → Workflow. If the flowchart has "AI decides" everywhere → Maybe agent.

Need help deciding whether your use case needs an autonomous agent or a workflow? We've built both and can show you the tradeoffs.

Get architecture advice →