AI Agents vs Traditional Automation: A Decision Framework With Real Costs

AI agents vs traditional automation comes down to one question: can you write the path in advance?

If you can, use traditional automation: scripts, RPA, or a workflow engine. At volume it costs a fraction of a cent per transaction, and its behavior is defined in advance. Use an AI agent only when the steps cannot be known ahead and a wrong action gets caught before it costs much.

What is the difference between AI agents and traditional automation?

Traditional automation runs logic a person wrote. A script, RPA bot, or workflow engine can branch and loop, but every branch is defined in advance. That alone does not make it safe: fixed code can mishandle valid-looking data or fail silently. Validation and error handling decide whether failures get caught.

An AI agent picks its own path. Anthropic’s Building effective agents draws the line. Workflows are “systems where LLMs and tools are orchestrated through predefined code paths.” Agents are “systems where LLMs dynamically direct their own processes and tool usage.”

That gives you four options, not two:

1. Rules automation. Code, RPA, or a workflow engine. No model.
2. An LLM step inside a fixed workflow. The path is still code. One step calls a model to read, extract, or classify, and code checks the result.
3. An assistant. The model retrieves or drafts, and a person acts.
4. An agent. The model chooses the steps and calls tools that act.

Most comparisons skip option 2, where much of the value sits.

Gartner’s June 2025 release maps to the same split. Analyst Anushree Verma said organizations “can start by using AI agents when decisions are needed, automation for routine workflows and assistants for simple retrieval.” It adds that “many use cases positioned as agentic today don’t require agentic implementations.” The autonomy ladder covers assistant versus agent, so this post stays on the line between rules and models.

When should you use an AI agent instead of automation?

OpenAI’s practical guide to building agents gives three tests: “complex decision-making” (refund approval with exceptions), “difficult-to-maintain rules” where updates have become “costly or error-prone” (vendor security reviews), and “heavy reliance on unstructured data” (a home insurance claim). Its closing line is the part people skip: if the use case does not clearly meet these criteria, “a deterministic solution may suffice.”

Anthropic adds a test about the path itself. Agents fit “open-ended problems where it’s difficult or impossible to predict the required number of steps, and where you can’t hardcode a fixed path.” It warns that autonomy “means higher costs, and the potential for compounding errors,” and that for many applications “optimizing single LLM calls with retrieval and in-context examples is usually enough.”

Together they give the rule I would apply to any proposal: an agent needs both messy input and an unknown path.

• Messy input with a known path calls for an LLM step inside a fixed workflow.
• Clean input with an unknown path usually means nobody has written the rules down. That is a process design problem, and a model will not fix it.
• Clean input with a known path is rules automation.

My heuristic, not a published threshold: if the owner can sign off on the full decision logic in one meeting, write it as code. If the rules change every few weeks, that is the “difficult-to-maintain” signal.

The decision framework: rules, LLM step, or agent

Start in the left column. Move one column to the right only when a row fails for your case. If any row in the agent column is false, do not build an agent yet.

Two rows do most of the work. The “same output” row is about audit. If an auditor expects the same invoice to post the same way every time, the calculation belongs in code.

The “cost of a wrong action” row is about blast radius. A bot’s failure paths are written and testable in advance. An agent with write access can choose a path nobody tested, finish, and be wrong. If you cannot detect or reverse that, stay one column to the left.

What does each option cost per transaction?

List prices below are as of October 15, 2026.

Serverless rules. AWS Step Functions Standard workflows cost $0.000025 per state transition in US East. AWS Lambda costs $0.20 per million requests and $0.0000166667 per GB-second on x86. A 10-step workflow with five short Lambda calls (200 ms each at 512 MB) costs $0.00025 + $0.000001 + $0.0000083, or about $0.00026, before free tiers.

Licensed RPA. Microsoft’s Power Automate Process plan is $150 per bot per month, paid yearly. A fixed cost, so cost per run depends on volume: about $0.0043 at 35,000 runs a month, $0.03 at 5,000. Maintenance labor comes on top.

A single model call. Per Anthropic’s pricing page, Claude Haiku 5.5 costs $0.10 per million input tokens (for prompts up to 100,000 tokens) and $0.50 per million output tokens. An extraction call with 3,000 input and 400 output tokens costs $0.0003 + $0.0002 = $0.0005. The same call on Claude Sonnet 5.5, at $2 and $10 per million, costs $0.006 + $0.004 = $0.010.

An agent loop. Say a Sonnet 5.5 agent makes five calls per task. The first sends 6,000 tokens. Each later call adds 1,500 tokens (a 1,200-token tool result plus the prior 300-token output). Input is 6,000 + 7,500 + 9,000 + 10,500 + 12,000 = 45,000 tokens, and output is 1,500. That is $0.090 + $0.015 = $0.105 per task.

Prompt caching cuts the repeated part. On Sonnet 5.5, a cache hit costs 5% of the input price and a 5-minute cache write costs 1.25 times it. Writing 12,000 tokens ($0.030), reading 33,000 ($0.0033), and the same output ($0.015) gives about $0.048. The Batch API takes 50% off for work that can wait.

The mechanism: agent cost grows faster than step count because every call rereads the history. Here the agent costs about 400 times the rules path and 210 times a single Haiku call, on this example’s assumptions. For the chatbot side of the cost question, see AI agents vs chatbots.

Worked example: 50,000 invoices a month

This is hypothetical. Only the prices and the wage are sourced. The rest are assumptions.

Assumptions. A company receives 50,000 invoices a month. 70% arrive as structured data (EDI or a supplier portal) that rules can post. 30% arrive as PDFs or emails in varied layouts. Any invoice the system cannot clear goes to a person, who takes 6 minutes. Labor uses the BLS median wage for bookkeeping, accounting, and auditing clerks: $50,670 a year in May 2025. At 2,080 hours that is about $24.36 an hour, or $2.44 per exception, wages only.

Four designs:

• A. Rules only. The 30% unstructured invoices all go to people.
• B. Rules plus one Haiku extraction call on the unstructured 30%, then validation rules (line items sum to the total, the PO exists). 85% pass. The rest, 4.5% of all invoices, go to people.
• C. A Sonnet agent on every invoice, no caching. It resolves 90%, and 10% escalate.
• D. Rules on the structured 70%, the agent on the other 30%. It resolves 90% of its share, so 3% of all invoices go to people.

What it shows. First, people cost more than software in every design. Second, design C spends $3,675 a month running an agent on 35,000 invoices that rules clear for about $9. For C to match B, its escalation rate would need to fall below about 0.2%. With caching, below about 2.5%.

Third, B and D are close, so reliability and control decide. Change one input. Say the unstructured invoices need lookups (an open PO search, a receipt match, a vendor question), and a single call clears only half of them. Design B rises to $0.366 per invoice, or $18,291 a month. Design D stays at $0.105. That is where an agent earns its cost: the exceptions need a path, not just reading.

Decision rule: price the human exception path first. If an option does not cut the exception rate, its token price does not matter. For where invoices break, see AI agents for accounts payable exceptions.

Reliability: why 95% is not good enough at volume

Rules give the same output for the same input. Model output does not, even at temperature 0. Thinking Machines Lab sampled Qwen3-235B 1,000 times at temperature 0 on the same prompt and got 80 unique completions. The main cause was batch size, which varies with server load. Unless your provider documents deterministic inference, assume the same input can produce different output.

Structured outputs fix most of the shape, not the facts. Anthropic’s structured outputs “guarantee schema-compliant responses through constrained decoding,” with listed exceptions: a refusal or a max_tokens cutoff can break the schema, and enum and const values may differ in capitalization with no error. So check stop_reason, compare enums case-insensitively, and validate every response. A schema-valid invoice can still carry the wrong total, which is why design B validates values too.

The τ-bench paper (June 2024) introduced pass^k: the chance an agent succeeds on all k tries of a task, averaged across tasks. GPT-4o then succeeded on under 50% of tasks, with pass^8 under 25% in retail. Newer models score higher. Anthropic’s guide to agent evals (January 2026) gives the arithmetic: 75% per trial means about 42% for three in a row.

Apply that to volume. At 95% per-run success, 50,000 invoices give 2,500 failures a month, and the chance that 20 invoices of the same type all succeed is about 36% (0.95 to the 20th power). At 99%, it is 500 failures and about 82%. These figures assume independent runs at one success rate. Real failures cluster on hard cases.

Early detection. Run each eval case several times and report pass^k. In the first month, I would send a 1 to 2% random sample of auto-cleared items to a person, and alert when the escalation rate drifts. The hallucination budget shows how to set an error ceiling per process.

Hybrid patterns that hold up

UiPath’s June 2025 post describes an era “where intelligent AI agents think, robots execute, and people lead,” with “deterministic tasks” given to robots. Vendor framing, but it matches the table. Three patterns hold up:

Rules first, model on the residue. Rules clear what they can. Only rejects go to an LLM step or an agent, as in designs B and D.

Model proposes, code disposes. The model returns structured fields. Code does the math, checks totals, and makes the write, so the part auditors care about stays deterministic.

Agent behind a gate. Read actions run freely. Write actions wait for approval until pass^k on your own cases earns more autonomy.

The failure mode of any hybrid is the handoff. A rules layer can silently drop a record with a null field. Count records in and out at each boundary. If the counts differ, stop the line.

To triage existing bots, see AI agents vs RPA. For where to build, see n8n vs custom code.

Bottom Line

Write the path in code whenever you can. At volume it is cheaper per transaction, and its behavior is defined in advance.

Add one model call when only the input is messy. Add an agent only when the path itself is unknown.

Price the human exception path before you price tokens. In the worked example, people cost more than software in every design.

Next step: split your highest-volume workflow into structured and unstructured shares and run it through the table.

FAQ

Is RPA the same as traditional automation?

RPA is one kind of traditional automation. It drives user interfaces the way a person would, while scripts and workflow engines usually call APIs directly. Microsoft prices unattended RPA per bot: $150 a month for Power Automate Process, or $215 for Hosted Process, which runs on a virtual machine Microsoft manages on Azure, both paid yearly.

Are AI agents cheaper than RPA per transaction?

It depends on volume. At 35,000 runs a month, a licensed bot costs about $0.004 per run against $0.05 to $0.11 per agent task. The $150 license is flat, so below about 1,429 tasks a month ($150 / $0.105), or 3,106 with caching ($150 / $0.0483), agent tokens cost less than the license alone. Build and maintenance are not in either number. At the example’s volume, the agent’s advantage comes from clearing exceptions that would otherwise go to people.

Can I make an LLM deterministic by setting temperature to 0?

Not on a typical hosted API. In the Thinking Machines test, outputs stayed identical for the first 102 tokens, then 992 of 1,000 said “Queens, New York” and 8 said “New York City.” Keep calculations in code and validate every value.

What does Gartner say about agents vs automation?

Beyond the advice quoted above, Gartner predicts over 40% of agentic AI projects will be canceled by the end of 2027, citing escalating costs, unclear business value, or inadequate risk controls. That is a forecast, not a measurement.

What is pass^k, and what number should I require?

pass^k is the chance an agent succeeds on all k runs of a task, averaged across tasks. For write actions without review, I would want pass^8 above 90% on your own eval set, measured directly by running each case 8 times. Do not convert from a per-run rate. That works only for one task with independent, identical trials (about 98.7% per run). If 91% of tasks always pass and 9% always fail, pass^1 and pass^8 are both 91%. The threshold is my judgment.

Three Ways to Work With TMA

Need an agent built? We deploy production AI agents in your infrastructure. Working pilot. Real data. Measurable ROI. → Schedule Demo

Want to co-build a product? We’re not a dev agency. We’re co-builders. Shared cost. Shared upside. → Partner with Us

Want to join the Guild? Ship pilots, earn bounties, share profit. Community + equity + path to exit. → Become an AI Architect