Skip to content
Novandri.

AI Agents vs Traditional Automation: What Is Actually Different

An agent decides which action to take, when, and with what arguments. That is a different kind of machine, with different costs and failure modes.

Rachmadwipa Novandri9 min read

The distinction that matters is not that an agent uses a language model. Plenty of language-model applications are not agents, and plenty of agents use no language model at all. The distinction is about where the decision loop sits: in traditional automation, the programmer writes the sequence of steps and the machine executes it; in an agentic system, the model chooses the next step at runtime from the situation it observes.

Direct answer: Traditional automation executes a path written in advance; an agent selects the next action at runtime, decides what arguments to pass, and decides how to use the result. The published evidence for agentic architectures describes exactly this selection capability, and it comes with a specific benefit — the ability to update a plan and handle exceptions — and a specific cost: the loop now depends on a probabilistic component whose failure modes are not compile-time errors. The honest way to choose between them is to ask whether the path can be specified in advance, not whether the task sounds sophisticated.

A comparison between automation: steps written once and agent: next step chosen live.
Conceptual: written sequence versus runtime choice. Use a tool for what the tool does well.

What traditional automation actually is

A conventional workflow is a program that someone wrote. It branches on explicit conditions, and every branch was anticipated by the person who wrote it. This is not a weakness — it is the source of its properties. The behaviour is inspectable, the failure modes are bounded and enumerable, and the system does exactly what it was told to do, including exactly the wrong thing when the input is unexpected.

The economics of traditional automation follow from that. It is expensive to build when the path has many branches, because each branch has to be written, tested, and maintained. It is cheap to run. And it is brittle in exactly one way: when reality produces a case nobody anticipated, it does something defined rather than something sensible.

Almost every internal tool, integration, and report-generation pipeline is in this category, and for a large fraction of them it is the right category.

What an agent actually adds

The mechanism is usually described loosely as "the model decides what to do". Two papers make it precise, and both are worth reading for the design details rather than the results.

Schick et al. describe Toolformer as "a model trained to decide which APIs to call, when to call them, what arguments to pass, and how to best incorporate the results into future token prediction". Four distinct decisions, all made at runtime, all learned rather than written. The training is self-supervised and needs "nothing more than a handful of demonstrations for each API", and the tools included were deliberately mundane: a calculator, a question-answering system, two search engines, a translation system, and a calendar. The reported effect is "substantially improved zero-shot performance across a variety of downstream tasks, often competitive with much larger models, without sacrificing its core language modeling abilities."

Yao et al. describe ReAct as generating "both reasoning traces and task-specific actions in an interleaved manner", and explain the division of labour: "reasoning traces help the model induce, track, and update action plans as well as handle exceptions, while actions allow it to interface with external sources, such as knowledge bases or environments, to gather additional information."

That is the real difference, and it is narrower than the marketing suggests. The agent is not "autonomous" in the sense of acting without feedback. It maintains a plan in text, revises it when an action returns something unexpected, and continues.

Traditional automation cannot revise a plan, because it has no representation of one.

The measured benefit follows from exactly that. On question answering and fact verification, Yao et al. report that ReAct "overcomes issues of hallucination and error propagation prevalent in chain-of-thought reasoning by interacting with a simple Wikipedia API".

The gain is not that the model knows more; it is that a checkable external source interrupts the chain where it would otherwise have compounded its own error.

The two things an agent is genuinely bad at

Two properties follow from the architecture, and both are documented rather than inferred.

The agent cannot do what the tools do. Schick et al. describe the paradox that motivates the whole approach: language models "paradoxically, struggle with basic functionality, such as arithmetic or factual lookup, where much simpler and smaller models excel". A calculator exists precisely because a language model is worse at arithmetic than a calculator.

The failure mode is not a crash. A traditional program that meets an unexpected input takes a defined branch, logs, and stops. An agent that meets an unexpected input reasons, acts, and acts again — plausibly, expensively, and possibly in a direction that is hard to predict from the outside. This is why agentic systems need the governance scaffolding that the rest of this publication covers: the accountability cannot be assigned to the model, so it has to be assigned to a person with a documented boundary of permitted actions.

Choosing between them

The decision is not "automation or agents". It is where in a workflow the decision loop belongs, and there are three useful placements.

Keep the loop in code. If the path can be enumerated — eight document types, six report formats, a fixed reconciliation — write the program. You get inspectability, deterministic cost, and testable behaviour for a fraction of the engineering effort. Reach for an agent only when the enumeration itself is the problem.

Let the agent plan, keep the execution deterministic. This is the pattern ReAct's evaluation demonstrates: the model decides what to look up and the tool performs a fixed operation. The model's uncertainty is confined to a decision that is cheap to check and easy to abandon.

Let the agent choose the tool. This is Toolformer's design: the model selects among a small, well-documented set of APIs. The risk is contained because the set of actions is bounded by what you integrated. An agent with access to thirty tools has thirty ways to be wrong on every step, and its success rate compounds.

A useful discipline for the third pattern is to keep the action set small and each action auditable, and to make the agent's plan observable — the reasoning trace is text, which means it can be logged, reviewed, and shown to a human when the run goes wrong.

A test to run before you build

  1. Can a competent person enumerate the steps? If yes, write the program. The agent version costs more and is harder to verify.
  2. Where exactly is the uncertainty? Name it. If it is in one step, put the model there and leave the rest as code.
  3. What can the agent actually do? List the tools. If the list is long, the compounding risk is real and you need tighter boundaries, not a better prompt.
  4. What happens when it is wrong? A refusal, a fallback, a page, a wrong-but-plausible action. The last of these is the one that needs a control.
  5. What does it cost per run? Token spend, latency, and the human review time are all part of the price, and the review time is usually the largest term.

None of this argues against agents. It argues for using them where the deciding — not the doing — is genuinely hard, and keeping the machinery around them as ordinary, inspectable software.

For how these systems are supervised, see AI Governance: Managing AI Responsibly at Scale; for the capability questions underneath, see The Limits of AI.

A worked example

The following is hypothetical and illustrative. A hypothetical firm processes three invoice formats and wants to automate data entry. The team first asks where the decision loop belongs, not whether the task sounds advanced. Three checks decide. First, can a competent person enumerate the steps? With three known formats, the path is fixed, so a conventional program handles extraction and validation; no agent is needed. Second, where exactly is the uncertainty? Suppose exceptions arrive as free-text notes from suppliers; the model is placed only at that step, leaving the rest as code, as the ReAct pattern of reasoning over a checkable external source suggests. Third, what can the agent do, and what happens when it is wrong? Its tool set is limited to a lookup API and a calculator, following Toolformer's mundane-tool design, and an unresolvable note pages a person. The outcome is bounded: token cost, latency, and review time stay visible, and the extra machinery is justified only if the exception step measurably reduces manual handling.

A counterargument

The "enumerate the steps, write the program" test is clean, but a reasonable critic would push back that enumeration is rarely stable in practice and that the article asserts agent costs without support from its own sources. Toolformer and ReAct are capability papers: they demonstrate improved zero-shot performance and hallucination resistance on question answering and fact verification with a Wikipedia API, not total cost of ownership, verification effort, or maintenance under changing inputs. The claim that an agent version "costs more and is harder to verify" is plausible but unmeasured in the cited work. Equally, traditional automation's failures are not as bounded as the opening suggests - the article concedes the program does exactly the wrong thing on unexpected input, which is an unbounded consequence from a finite set of branches. The framing is incomplete where it treats a design heuristic as a settled cost comparison.

References & Further Reading