Every multi-step AI workflow is starting to look like an agent.
That is a design mistake.
An agent is useful when the work is open-ended: it must interpret an unclear situation, choose between tools, gather context and decide what to do next. When the steps are already known, ordinary software is usually easier to test, cheaper to run and more predictable.[2]
Microsoft made this distinction explicit in new Azure guidance published on 30 October 2026. It recommends an agent for open-ended tasks that need model-driven tool selection, and an ordinary function or deterministic workflow when the steps are known in advance. It also warns that adding a language model does not improve a process simply because it is there.[2]
The operator lesson is simple:
Reserve reasoning for uncertainty.
Do not ask an agent to improvise through work that your team can already describe as a stable procedure.
Start with the accepted outcome
Before choosing a model or agent framework, define the completed work.
For invoice processing, the accepted outcome might be:
One supplier invoice has been extracted, validated, matched to the correct purchase order, coded correctly, and either posted for payment or routed as a documented exception.
That definition matters because “the agent ran” is not a business result.
An invoice may pass through extraction, validation, matching, investigation, approval and an ERP update. Some steps need language understanding. Some need judgment. Others should follow a fixed rule every time.
Microsoft’s current process-transformation guidance recommends starting with the business outcome, redesigning the workflow around it, and measuring speed, quality, cost and capacity before expanding.[5]
That is a better starting point than deciding, “We need an invoice agent,” and then forcing every step through one model.
Split the workflow into three lanes
A useful workflow is rarely fully deterministic or fully agentic. It is a combination.[2]
Lane 1: Deterministic execution
Use ordinary functions, rules and database operations when the expected action is stable.
In invoice processing, that includes:
- Confirming that required fields are present.
- Checking whether line items add up to the total.
- Detecting an exact duplicate invoice number.
- Matching a known supplier identifier.
- Applying a fixed approval threshold.
- Writing an approved result to the ERP.
These steps should not change their answer because a model phrased the problem differently. They need explicit rules, clear errors and reliable logs.
Deterministic does not mean risk-free. Code can contain bugs. Data can be wrong. Integrations can fail. But the behaviour is easier to reproduce, trace and test against a known expected result.
Lane 2: Model-assisted interpretation
Use a model for bounded language work where the output categories and limits are known.
Examples include:
- Extracting a supplier reference from inconsistent text.
- Classifying a description into an approved expense category.
- Normalising an address or delivery note.
- Drafting a short explanation for a routine mismatch.
A smaller model may be enough here. The task does not require the system to invent a plan or choose freely among many tools. It needs to interpret language within a narrow contract.
The acceptance test should remain concrete. Did the extracted reference match the document? Was the category selected from the approved list? Did the explanation cite the fields that caused the mismatch?
Lane 3: Agentic reasoning
Use an agent when the next step cannot be fully known in advance.
For example:
- The invoice total matches the purchase order, but the delivery record is incomplete.
- The supplier has changed its legal name and several records disagree.
- The invoice may be valid, but the cost centre is unclear from the current document.
- The system must inspect prior transactions, query more than one source and decide which evidence is missing.
Here the agent can gather context, select tools and prepare a recommendation. It should not quietly turn ambiguity into approval. When the evidence is insufficient or the consequence is material, the correct outcome is an explained escalation to a person.
The agent handles the exception. It does not need to own the arithmetic, the duplicate check or the final database write.
Use a five-question decision test
Review every workflow step with five questions.
1. How uncertain is the input?
If the input is structured and the rule is clear, use deterministic execution. If the meaning is messy but the output is bounded, use model assistance. If the situation itself changes what should happen next, consider an agent.
2. How stable is the rule?
A long-standing finance policy should be encoded as a rule. A judgment that depends on new evidence may need reasoning. Do not hide policy inside a prompt when it can be stated and tested directly.
3. Must the system choose tools dynamically?
If every invoice follows the same sequence, orchestrate that sequence explicitly. If different exceptions require different systems and investigation paths, agentic tool selection may be useful.
4. What error is acceptable?
A rough internal classification may tolerate review. Posting the wrong amount for payment should not. The lower the acceptable error, the stronger the validation and approval requirements.
5. When must the workflow escalate?
Define stop conditions before deployment. Missing evidence, conflicting records, policy exceptions and irreversible actions should have named owners and clear handoff data.
This test prevents “agent” from becoming a fashionable label for every automation.
Measure the complete path
Token spend is only one cost.
A workflow can use a cheap model and still be expensive if it retries repeatedly, creates duplicate work or needs constant human correction. A more capable model may justify its price on difficult exceptions if it reduces rework. The answer comes from the full workflow, not a model ranking.
Track at least:
- Accepted outcomes: How many invoices passed the stated acceptance test?
- First-pass acceptance: How many completed without correction or retry?
- Exception rate: How many left the normal path?
- Human review time: How much attention was needed to check or correct outputs?
- Machine cost: Models, retrieval, tools, APIs and workflow infrastructure.
- Cycle time and capacity: How quickly and reliably did accepted work move through the process?
Microsoft’s Azure guidance recommends tracing the whole request path rather than looking only at model token counts.[2] That trace should show which step ran, which evidence it used, what failed, where a person intervened and whether the final work was accepted.
Build a small test company first
Do not begin with live volume.[3]
Microsoft Research recently described using synthetic enterprise environments and industry-specific workflows to test Copilot against realistic work without using customer data.[3] An SME can apply the same principle on a smaller scale.
Create a test pack containing:
- 20 normal invoices that should follow the deterministic path.
- 10 ambiguous documents that need bounded interpretation.
- 5 policy exceptions that must stop for human review.
- Expected outputs and pass/fail criteria for every case.
- Traces showing each tool call, decision and escalation.
Run the pack repeatedly. Check whether the same normal cases produce the same accepted outcome. Review whether ambiguous cases cite the right evidence. Confirm that policy exceptions stop instead of slipping through.
Then change one variable at a time: the model, the instructions, the tool set or the routing rule.
Orchestrate, do not over-agent
The goal is not to remove agents from the workflow.
It is to put reasoning where reasoning earns its cost.
Use deterministic software for settled procedure. Use models for bounded interpretation. Use agents for open-ended exceptions that need context and tool choice. Keep humans responsible for the decisions the system is not authorised or equipped to make.
That architecture is usually less impressive in a demo than one agent doing everything.
It is also much easier to operate.
Sources
[2] https://techcommunity.microsoft.com/blog/startupsatmicrosoftblog/ai-on-azure-platforms-for-apps-and-agents/4569086 — AI on Azure: platforms for apps and agents
[3] https://www.microsoft.com/en-us/research/blog/from-synthetic-enterprise-data-evaluations-to-real-microsoft-copilot-ai-confidence — From synthetic enterprise data evaluations to real Microsoft Copilot AI confidence
[5] https://www.microsoft.com/en-us/microsoft-cloud/blog/general/2026/10/29/accelerating-frontier-transformation-reshape-business-processes — Accelerating Frontier Transformation: Reshape business processes