Not every process that uses a language model needs to become an agent. This distinction seems obvious, but it has become more difficult as automation tools have incorporated LLMs, tool calls, memory, and dynamic routing. The result is that very different systems end up receiving the same "agent" label, even when execution remains rigidly defined by code.
The most useful question is not "can you do it with an agent?". In many cases, the technical answer will be yes. The question that reduces cost and risk is another: which part of the process really needs to decide the next step at runtime? If the path can be known before starting, agent autonomy may be a cost without commensurate benefit. If the path depends on what is discovered during execution, an adaptive flow starts to make sense.
The central difference is who controls the flow
Anthropic makes a clear architectural separation: in workflows, models and tools are orchestrated along predefined paths; in agents, the model itself dynamically directs the process and the use of tools. Microsoft describes the same difference in its documentation: in a deterministic workflow, the code defines sequence, branches, parallelism and error handling; In an agent-driven flow, the model decides which tools to use, in what order, and when to end the task.
This distinction eliminates an important misunderstanding. A deterministic workflow can use AI. It can call an LLM to classify text, extract fields, summarize a document, generate a response, or evaluate a condition. What remains deterministic is process control: the model performs a function within a step, but does not freely choose what the next step will be.
So there are more options than just “traditional automation” or “agent”. Between the two extremes lies a broad range of architectures in which AI is used only where uncertainty requires judgment, while rules, integrations, validations, and critical actions remain under explicit control.
Four levels of autonomy before thinking about multi-agents
Automation without LLM
When inputs, rules and outputs are structured, a common workflow is often sufficient. Triggers, conditions, transformations, API calls, and data persistence can be modeled directly. Adding a model to an already accurate rule tends to increase variability, cost, and difficulty of testing without solving a real problem.
An LLM call within the workflow
Many processes only need AI at a specific point. An email can be classified, a contract can have fields extracted, a description can be normalized, or text can be summarized. After that, the workflow takes back control. Anthropic itself recommends starting with the simplest solution and notes that, in many applications, a single well-designed LLM call, possibly with context retrieval and examples, is enough.
Hybrid architecture
In hybrid architecture, the skeleton of the process remains explicit, but one or more steps receive modeled decision capabilities. An agent can investigate an exception, select a tool from a limited set, or produce a recommendation; Then the flow returns to a deterministic step to validate format, apply policy, record evidence, or request human approval. Google uses exactly this combination in its agentic automation documentation for security operations: adaptive agents can be inserted into deterministic playbooks, keeping critical actions in flow control.
Agent with own loop
The agent becomes appropriate when the number or order of steps cannot be predicted in advance. The model observes the state, chooses an action, uses a tool, evaluates the result and decides the next step. This pattern is useful for open-ended research, complex diagnosis, conversational tool-based tasks, and problems where the strategy needs to change as new information appears.
Multi-agents are an additional step of complexity, not a starting point. If a single agent can plan and execute the task with well-defined tools, dividing the process between coordinators and specialists must have a measurable justification, such as real specialization, useful parallelism or separation of responsibilities.
The decision matrix: seven criteria that matter more than the label
The choice becomes clearer when the process is evaluated using independent criteria. They do not form an automatic score. A single factor, as a serious consequence of an error, can weigh more than all the others. The goal is to reveal where autonomy creates value and where it merely transfers control from code to a probabilistic model.
1. Path predictability
If the steps are known, repetitive, and change little from one run to the next, the case is strong for deterministic workflow. Google characterizes this type of workload as predictable, sequential and with a clearly defined path. Microsoft also recommends traditional automation for stable, known, and predictable processes.
When each request may require a different sequence, the analysis changes. Processes with frequent exceptions, the need to choose tools according to intermediate results or planning that can only be done after observing new data favor adaptive execution. Still, the dynamic part can be isolated in one part of the process instead of dominating the entire flow.
2. Input ambiguity
Unstructured input is not synonymous with agent. A PDF, email, audio, or free text can be ambiguous by traditional rules and still require only a well-defined transformation. If the task is "extract these fields" or "sort between these categories", a model call within a workflow can solve the problem without handing control over the orchestration to the model.
The agent begins to gain ground when ambiguity affects not only the interpretation of the data, but the strategy itself. If, after reading the input, the system needs to decide what to investigate, which source to consult, what questions to ask, or what sequence of actions to follow, there is a real need for a run-time decision.
3. Need for judgment and planning
There is a difference between local judgment and global planning. Local judgment is choosing a class, estimating relevance, summarizing, extracting or evaluating a response. Global planning is deciding how to break down the problem and coordinate tools until you reach a goal. The first naturally fits into an AI step within a fixed flow. The second is typical agent territory.
Google's documentation separates deterministic workflows from cases that require dynamic orchestration, in which the system needs to plan, delegate and coordinate tasks without a predefined script. This is a more useful boundary than asking whether the process "uses reasoning." Almost every LLM application may involve some judgment; Few need to let the model control the entire process.
4. Reversibility of action
The more difficult an action is to undo, the less autonomy should be granted without additional controls. Reading data, generating a draft or putting together a recommendation is different from sending money, deleting records, changing production, granting access or communicating something externally on behalf of the company.
An architecture can use an agent for analysis and still reserve the final execution to a deterministic step or human approval. Anthropic highlights this principle of human control by treating different permissions for reading actions and actions that produce external effects. Google also associates human supervision with tasks with greater risk or subjectivity.
5. Consequence of the error
It is not enough to estimate the probability of failure. This probability must be multiplied by the impact. A mistake in an internal suggestion can be cheap; the same mistake in a financial, security, or access decision can be costly even if it occurs rarely. The greater the consequence, the more important it becomes to limit tools, define explicit policies, validate exits, and create stopping points.
In critical processes, the question is no longer "does the agent get it right most of the time?" and becomes "what's the worst effect a bad decision can have before someone notices?" This shift in focus helps you decide where to insert human approval and which actions should remain outside the agent's direct reach.
6. Cost and latency
Agents tend to trade predictability for flexibility. They can make multiple model calls, query tools repeatedly, reconsider plans, and run evaluation cycles. Anthropic warns that agentic systems often increase latency and cost in exchange for better performance in tasks that really require this complexity. Google also points to high latency and operational cost in more complex coordination and decomposition patterns.
Therefore, a task with a short SLA or very high volume deserves a simple baseline before any agentive loop. If a single inference solves 95% of the cases and the remaining 5% can be forwarded for review or exception, it may be economically better to treat the tail separately than to turn 100% of the executions into agents.
7. Observability and auditability
The more a process needs to be explained, reproduced or audited, the more valuable it is to have an explicit flow. Microsoft puts the need for clear guardrails and reviewable control as a reason to choose deterministic workflows. In adaptive systems, this does not mean abandoning agents, but requiring tracing, tool logs, intermediate states, stopping criteria, and approval records.
Observability also affects debugging. In a fixed flow, it is relatively simple to locate the failed step. In an agent, the failure may be in the interpretation of the objective, in the choice of tool, in the data received, in the sequence of actions or in premature termination. If the team cannot observe these decisions, autonomy becomes an operational black box.
A decision method that starts with process, not technology
Draw the path without AI first
Before choosing a tool, describe how the process works today. Identify inputs, outputs, rules, integrations, exceptions and human decisions. This shows which parts are already deterministic and which are up to interpretation or investigation.
Separate rule, judgment and planning
For each decision, ask whether it can be written as an objective rule, whether it requires model judgment with limited output, or whether it requires figuring out the next step during execution. Rule goes to code or workflow. Limited judgment may turn into an LLM call. Dynamic planning is a candidate agent.
Place approval where the impact changes class
Human approval does not need to appear at every stage. It is most useful before irreversible, external, financial, privileged, or difficult-to-correct actions. The agent can prepare context, compare alternatives and recommend an action, leaving to the person only the decision that really requires responsibility.
Test the simplest solution as a baseline
Start with the smallest architecture capable of performing the task: traditional automation, an LLM call, or a small thread with validations. Measure quality, cost, time, exception rate and quantity of human intervention. Only increase autonomy when there is evidence that the simple version fails due to lack of adaptation, not because of a bad prompt, bad data or incomplete integration.
Set a autonomy budget
A practical way of thinking is to treat autonomy as a scarce resource. Each permission granted to the model increases the action space and therefore the error surface. The budget should only increase where there is a concrete gain: fewer manual exceptions, better coverage of ambiguous cases, time reduction or ability to solve tasks that a fixed flow cannot represent.
Process 1: reimbursement of expenses
A reimbursement system rarely needs to be fully agentive. Receiving the receipt, validating format, extracting value, identifying cost center, checking duplicity and comparing limits can follow a known workflow. An LLM may come in just to extract data from miscellaneous documents or classify the nature of the expense.
The agentive section appears in exceptions: lack of information, ambiguous policy, divergence between receipt and declaration or need to locate an internal rule. At this point, an agent can look for authorized documents, explain the inconsistency and propose what to do. Financial action, however, may remain conditioned on deterministic rules and human approval when the amount, exception or policy exceeds defined limits.
This decomposition avoids using an agent to repeat hundreds of trivial steps, but preserves flexibility precisely where rigid flow tends to break down.
Process 2: B2B technical support
Authenticating the customer, identifying contract, uploading history, applying SLA and registering ticket are deterministic steps. Summarizing the report or classifying the subject can be done by an LLM call. If the problem is known, the workflow itself can trigger a predefined diagnostic procedure.
An agent becomes useful when the incident is opened: it needs to choose queries, correlate logs, formulate hypotheses and change the investigation according to results
intermediaries. Even so, actions such as changing production configuration, restarting critical services, granting credit, or changing permissions may lag behind explicit validations or human approval.
The advantage of the hybrid is to preserve speed in the investigation without transforming the entire service into an unpredictable sequence. The agent decides where uncertainty requires exploration; workflow protects operational boundaries.
Process 3: research and report production
If the scope is fixed, the sources are known, and the report follows a stable model, a workflow can collect data, normalize results, and call an LLM once or twice for synthesis. There is no automatic advantage to creating an agent just because the material is textual.
Research becomes agentive when the question is open-ended and the next source depends on what was found. The agent can formulate queries, select tools, compare evidence, and decide when there is enough information to close. The final step of publishing, sending to clients, or using the conclusion in a high-impact decision can remain separate, with human review and quality criteria.
This example shows why “using AI” and “using an agent” are not synonymous. The same process may start deterministic, open an agentive window of inquiry, and end again in a controlled flow.
Signs that you are acting too soon
The first sign is when the main justification is the format of the input. Free text, PDF or conversation justify the use of a model, but not necessarily autonomy. The second is when the team cannot pinpoint which next step decision needs to be made at runtime. If all the transitions are already known, there is probably a workflow hidden behind the name "agent".
Another sign is the absence of a baseline. Without comparing the agent to a simple version, it is not possible to know whether the additional complexity actually increases quality or just adds calls, latency, and debugging difficulty. Anthropic's recommendation to start with the simplest solution is especially useful here because it avoids turning architecture into a technology demonstration.
It is also an alert when the agent receives direct access to high-impact actions before logs, limits, permissions and approval points exist. Autonomy should not be confused with the absence of governance. The more freedom the system has to decide, the more important it is to define what it can do and how its decisions will be observed.
Hybrid architecture is not a generic compromise
Calling something hybrid only makes sense when there is a conscious division of responsibilities. The workflow must control what is stable, testable and regulated by rules. AI must handle interpretation where rules become fragile. The agent should only assume the sections where the path needs to be discovered during execution. And one must remain at points where context, responsibility, or impact make a completely automatic decision inappropriate.
This composition can be simple. An agent does not need to control the entire application. It can be a step in a larger process, given limited tools, returned a structured result, and closed. Google precisely describes the combination of agents with deterministic steps, and Microsoft treats code-driven workflows and agent-driven loops as approaches that can coexist in the same architecture.
Final rule: only give autonomy to the section that needs it
If the path is known, use workflow. If the path is known, but a step requires interpretation, place AI within the workflow. If only a few exceptions require exploration, use a hybrid architecture. If the task is open-ended and the system itself needs to discover, test and adapt the sequence of actions, use an agent. And if a single model call solves the problem, there's no technical prize for turning that into an agent.
The mature decision is not to choose the most autonomous option. It means choosing the lowest level of autonomy that can deal with the real variability of the process, keeping cost, latency, risk and observability at acceptable levels. Agents are valuable when they remove the rigidity that prevents the process from moving forward. Beyond this point, determinism remains an advantage, not a limitation.
