AI Agent or Automation: A Practical Decision Model

“Let’s build an agent” often appears before the problem has been described.

A team sees a slow or awkward process, chooses a model, connects tools and only then tries to define what the system should improve.

That order makes an impressive demo—and an expensive operational problem—more likely.

An AI agent is not the highest stage of every automation. It is one architectural option. It helps when a system must choose its next step in a changing context. Alongside that flexibility, it adds:

variability;
cost;
latency;
state management;
new failure modes;
quality-evaluation requirements;
authority and control;
more difficult recovery.

The practical question is therefore not:

Which agent framework should we use?

It is:

Which part of the process genuinely requires the system to choose its own path, and which part should remain ordinary, verifiable automation?

The short answer

Use a deterministic workflow when:

the sequence is known;
business rules can be stated;
inputs are structured;
exceptions can be listed;
the outcome must be repeatable;
an error has material consequences.

Use an AI assistant when:

text, an image or speech needs interpretation;
a draft, classification or recommendation is useful;
a person remains the decision owner;
the result can be checked quickly.

Use a bounded agent when:

the goal is clear but the path is not known in advance;
the system must choose tools from the context it finds;
several iterations are required;
intermediate results change the next step;
the final outcome can be verified;
time, cost and authority are limited.

Use a multi-agent architecture only when the task genuinely benefits from parallel specialisation and its value justifies the additional coordination cost.

Autonomy is not a feature—it is a cost

In a conventional workflow, code determines the next step. In an agentic system, part of that decision is delegated to the model.

This creates useful adaptability. It also means that two runs with the same starting point may:

choose different tools;
take a different number of steps;
request different sources;
finish at different costs;
encounter different errors;
reach different but formally acceptable outcomes.

For a research task, that variability can be an advantage. For updating a CRM price, it is a defect.

The Methodfield view

Complexity should be earned.

Do not add autonomy because a platform offers it or because it looks better in a presentation. Add it after a simpler level has failed to remove a measurable bottleneck.

If a process can be fixed by a rule, form or integration, an agent does not make the solution more mature. It makes it less predictable.

A five-level maturity ladder

Level 0. Remove or change the process

Before automating, test whether the process is needed in its current form.

Useful questions include:

Why does this step exist?
Who uses the result?
What happens if the step is removed?
Which data is requested repeatedly?
Where is a decision waiting for unnecessary approval?
Which “exception” has actually become the normal case?

Removing three unnecessary steps can create more value than AI while reducing the future surface for errors.

Level 1. Deterministic automation

This works well for:

synchronising fields;
creating a task after an event;
applying a formula;
checking required data;
routing by a known rule;
sending a fixed notification;
assembling a document from approved blocks.

Its advantages are:

repeatability;
low cost;
straightforward testing;
clear responsibility;
easy audit;
predictable rollback.

A model is not needed to check whether an email field is populated.

Level 2. AI assistant

The model performs bounded cognitive work but does not manage the process.

Examples:

classify an enquiry;
extract requirements;
summarise a conversation;
find contradictions in a document;
prepare a response draft;
suggest options;
mark uncertainty.

The system determines when to call the model, the output format and the next step. A person or deterministic rule decides what happens next.

For many small businesses, this is the most useful first level of AI: it reduces manual preparation without giving the system authority over a consequential action.

Level 3. Bounded agent

An agent chooses its path inside a predefined envelope.

For example, an agent may be asked to prepare a briefing on a prospective customer. It can:

choose among permitted sources;
search for additional context;
vary its search queries;
compare information;
stop when it has enough evidence;
produce a structured result.

It cannot:

write to the customer;
change the CRM;
buy data;
exceed its budget;
use an unknown tool;
continue indefinitely.

The goal is clear, the path is variable and the consequences are limited.

Level 4. Multi-agent system

Several agents make sense when a task can be split into independent streams that run in parallel.

Anthropic describes this approach for open-ended research: a lead agent divides the task, specialist agents search different directions, and the result is then synthesised and checked.

Anthropic also notes the high cost. In its internal data, agents used roughly four times as many tokens as ordinary chat and multi-agent systems roughly fifteen times as many. These are not universal benchmarks; they describe one system. The direction still matters.

A multi-agent architecture is justified when:

real parallelism exists;
the streams depend only loosely on each other;
there is more information than one context can handle conveniently;
the task has high value;
completeness matters more than minimum cost;
every branch can be checked.

It is a poor fit when:

every worker needs the same changing state;
the steps are strictly sequential;
the task is simple;
the result is needed in seconds;
coordination costs more than the work;
an error is difficult to localise.

Decision matrix

Outcome clarity	Path clarity	Best starting option
Outcome is clear	Path is clear	Deterministic automation
Outcome is clear	One step needs interpretation	Workflow with an AI assistant
Outcome is clear	Path changes with context	Bounded agent
Outcome is clear	Independent parallel streams exist	Possibly a multi-agent system
Outcome is unclear	Path is clear or unclear	Define the process and decision owner first
Consequences are high	Any path	A person makes the final decision

This matrix does not select a product. It selects a level of autonomy.

A deterministic frame around AI

Most production systems do not need to be completely deterministic or completely agentic.

A more practical architecture is:

Deterministic trigger
→ input validation
→ AI for the uncertain step
→ deterministic validation
→ risk-based approval
→ external action
→ final-state measurement

Text alternative: an event starts verifiable rules; AI is used only for interpretation or search; the result passes deterministic validation; a person approves high-consequence actions; after execution the system verifies the final state.

Microsoft describes a similar spectrum: each step may use a deterministic executor, an agentic executor or a human-in-the-loop gate. That is more useful than declaring an entire process to be an agent.

Example: an inbound customer enquiry

Consider this workflow:

Customer email
→ extract requirements
→ identify missing information
→ prepare a response
→ confirm price and terms
→ send
→ update CRM

The steps do not need the same architecture.

Step	Recommended mechanism	Why
Receive the email	Deterministic integration	Event and source are known
Extract requirements	AI assistant	Free text needs interpretation
Check required fields	Rules	Conditions can be listed
Find additional context	Bounded agent if needed	Search path may vary
Prepare a draft	AI assistant	Text adaptation is useful
Confirm price and promises	Person + approved rules	Error cost is high
Send the exact version	Deterministic action	Repeatability and audit are required
Update CRM	Idempotent automation	Fields and object are known

The whole workflow can be called an “AI system,” but only one or two steps genuinely need agentic behaviour.

Why the demo misleads

A demo usually shows a direct successful path:

the prompt is good;
the data is available;
the tool responds;
the model chooses a reasonable step;
the result is accepted.

Production adds:

incomplete inputs;
stale rules;
duplicate events;
unavailable APIs;
schema changes;
concurrent updates;
delays;
limits;
partially completed operations;
the need to resume a run after failure.

Anthropic notes that agents preserve state across many tool calls and that errors accumulate. Checkpoints, resumability, tracing and deterministic safeguards are therefore necessary.

The last mile often becomes most of the project.

Economics: count the verified outcome

Comparing only the price of one model call is not enough.

Total cost includes:

tokens and tool calls;
retries;
state infrastructure;
observability;
evaluations;
manual approval;
error correction;
integration support;
rule updates;
recovery after partial completion.

Google Cloud reports that 83% of participants in its research consider infrastructure upgrades necessary for production-grade agentic AI, while 81% identify operational complexity and engineering overhead as significant unexpected costs. The research focuses mainly on enterprise infrastructure, so its percentages cannot be transferred directly to a small business. The direction is still relevant: agentic load creates work around the model.

A useful small-business measure is:

Cost of a verified outcome =
model
+ tools
+ infrastructure
+ review
+ corrections
+ support

If an agent saves five minutes but needs ten minutes of review and regular recovery, the automation does not pay.

Metrics by level

For a deterministic workflow

completion rate;
execution time;
number of technical errors;
duplicate operations;
manual time spent on exceptions.

For an AI assistant

correction rate;
review time;
share of accepted drafts;
extraction errors;
cost per accepted outcome.

For an agent

task success measured by final state;
average and maximum number of steps;
tool error rate;
share of runs stopped by a limit;
recovery after failure;
permission-policy violations;
cost per verified outcome;
share of manual escalations.

For a multi-agent system

completeness of the result;
duplicated work between agents;
coordination cost;
time of the slowest branch;
synthesis quality;
evidence lost during handoff;
difference from a single-agent baseline.

A multi-agent system cannot be evaluated only by the fact that it “used several specialists.”

Ten questions before choosing the architecture

Which measurable bottleneck are we removing?
Can the step be removed or simplified?
Is the correct sequence known?
Where is interpretation needed, and where is a rule enough?
How will the final outcome be verified?
What is the cost of an error?
Which actions are reversible?
Who owns the exceptions?
How much time and money may one run spend?
What must a simple prototype prove before autonomy is expanded?

If the answers are unclear, it is too early to choose a model or framework.

Common mistakes

Automating a broken process

AI accelerates movement between unnecessary steps but does not create an owner, a rule or a clear outcome.

Calling a group of integrations an “AI employee”

The term hides responsibility. List the actual actions, permissions and approval points instead.

Giving an agent an unclear outcome

Autonomy does not create business clarity. It automates ambiguity.

Using a multi-agent architecture without parallelism

Several agents sequentially retell the same context to each other, increasing cost and the risk of losing information.

Treating polished final text as success

Verify the final business state: was the right object created, was the right version updated, and was only the permitted action taken?

Adding a person after every step

Excessive approvals become mechanical clicks. Human review should match the consequences rather than compensate for missing architecture.

Recommended implementation path

Step 1. Establish the baseline

Measure:

operation volume;
manual minutes;
waiting time;
error and rework rate;
cost of exceptions.

Step 2. Simplify the process

Remove repeated data entry, unnecessary approvals and steps whose output nobody uses.

Step 3. Automate what is known

Implement events, rules, routing and writes deterministically.

Step 4. Add one AI step

Choose an interpretation or draft that is easy to verify.

Step 5. Test a representative sample

Include ordinary cases, incomplete data, exceptions and integration failures.

Step 6. Add bounded autonomy

Do this only if the evidence shows that a fixed path does not handle the real variation.

Step 7. Expand after proof

Add new tools, parallel agents and external actions one at a time, each with its own metrics.

Final position

An AI agent is not useful because it can perform many steps.

It is useful when:

the outcome is clear;
the path genuinely varies;
the permission envelope is bounded;
the final state is verifiable;
the cost is justified;
recovery is designed.

Most practical systems should remain deterministic around the small part where AI genuinely adds value.

Use rules for what is known. Use AI for interpretation. Use an agent for bounded uncertainty. Use a person for decisions with material consequences.

Sources

Microsoft Learn, Workflows (opens in a new tab), version available on 29 July 2026.
Microsoft Learn, Workflow-oriented multi-agent patterns (opens in a new tab), updated 20 May 2026.
Microsoft Learn, Use the agent design framework (opens in a new tab), version available on 29 July 2026.
Anthropic, How we built our multi-agent research system (opens in a new tab), 13 June 2025.
Anthropic, Demystifying evals for AI agents (opens in a new tab), version available on 29 July 2026.
Google Cloud, State of AI infrastructure report and the Agentic Data Cloud (opens in a new tab), 23 July 2026.

Does This Process Need an AI Agent? Choose Between Rules, Automation and Autonomy