Agentic process automation (APA)

What is agentic process automation (APA)?

Agentic process automation is a business process in which three kinds of workers share the steps. Deterministic automation (an RPA bot, an API call, a cloud flow) does the fixed steps. An AI agent built on a large language model does the steps that need reading and judgement. A person does the steps you are not willing to hand to either. One orchestrator holds the process model and passes the case from one to the next.

The name comes from the RPA vendors. Automation Anywhere has sold an "Agentic Process Automation System" since June 2024 and describes the idea as AI agents that build flexible workflows and complete tasks without a person stepping in. UiPath calls the same pattern agentic automation and sums it up as "AI agents reason, robots act, and people lead". Microsoft does not lean on the acronym; in Copilot Studio the agent decides and deterministic "agent flows" do the work. Whatever the label, the shape is the same: a process with agent tasks, robot tasks and human tasks side by side.

The useful way to read the term is as the next step in the RPA lineage. RPA gave you a bot that repeats clicks. IPA put a trained model next to the bot so it could read a PDF. APA puts a model in the process that can decide what to do with what it read.

What the agent adds to the bot, and what it does not

A classic RPA bot fails at three points: unstructured input, a choice that was not in the script, and an exception. Each of those used to become a ticket for a person. The agent takes over exactly those three points.

It reads unstructured input. A supplier mail that says "invoice attached, the price went up as agreed with Tom in March" is unusable for a bot and perfectly usable for an agent.

It chooses the next step. Instead of a fixed branch, the agent is given a goal, a handful of tools (look up the purchase order, check the goods receipt, read the mail thread with the supplier) and a set of allowed outcomes. It picks which tools to call and in what order, then returns a structured outcome the process can route on.

It handles exceptions that used to go to a person. A price mismatch of a few percent with a mail trail that explains it no longer needs a human; the agent resolves it and writes down why.

Three things do not change. The bot still clicks the ERP, because the agent has no business typing into a screen it might misread. The process still needs a model, in BPMN or a workflow designer, that says which step is agentic and which is not. And the process still needs an owner who signs off on the outcomes the agent may pick on its own. Take the model or the owner away and you have an agent with tools, which is a different and riskier thing.

Three task types in one process

Draw the process and colour every step one of three ways.

1. Deterministic task
   Same input, same output, every time. Fetch, extract with a fixed template, post to the ERP, send a standard mail. Bots, API calls and cloud flows live here. Microsoft's own description of an agent flow is the definition: it follows a rule-based path and the same input always produces the same output.

2. Agentic task
   The model is given the case, a goal, tools and the list of outcomes it may return. In UiPath Maestro this is an agent task on the canvas whose structured output (say decision = approved or rejected) feeds the next gateway, with an escalation path for the cases it should not settle alone. In Copilot Studio the agent picks which flows and tools to call from their descriptions.

3. Human task
   The process pauses until someone in a task inbox approves, corrects or rejects. Put these where the money, the customer or the legal exposure sits, not where the agent happens to be unsure.

Worked example: supplier invoices

A wholesaler receives about 600 supplier invoices a month. The old RPA version fetched each PDF from the mailbox, ran it through document extraction, matched it to the purchase order, and booked it if the amounts were equal. Roughly one invoice in four did not match and went to a person.

The agentic version keeps the first steps as they were: a bot fetches the PDF and the extraction runs unchanged. When the three-way match fails, an agent task starts. The agent sees the invoice, the purchase order, the goods receipt and the last ten mails with that supplier. Its allowed outcomes are approve, reject and escalate, and it must return a one-paragraph reason with each.

An invoice of 1,236 euro against a purchase order of 1,200 euro, with a mail from the buyer in March confirming a 3 percent price rise, comes back as approve with the mail cited. An invoice with a quantity that exceeds the goods receipt comes back as reject with a draft mail to the supplier. Anything above 2,500 euro, or any mismatch above 5 percent, is routed to a human task regardless of what the agent thinks. In every case the final booking is posted by the bot; the agent never touches the ERP.

Of the 150 monthly mismatches, the agent now closes the ones that have an explanation in the data, and the accounts payable clerk sees the rest with the reasoning already written. That is the whole promise of APA in one process: the person stays, the queue in front of the person gets shorter.

APA versus RPA, IPA and hyperautomation

RPA versus APA: who decides the next step

In RPA a script written by a developer decides the next step; the bot cannot take a branch nobody drew. In APA a model decides the next step inside the boundaries of the agent task, and the process model decides everything outside it. That single difference explains the rest: why APA handles exceptions, why it costs more per case, and why it needs testing that RPA never needed.

IPA versus APA

Intelligent process automation added machine learning models to RPA for classification and extraction: which supplier is this, what is the total, is this a complaint or an order. The model gave an answer; the script still decided what to do with it. APA moves the decision itself into the model. If a vendor's "agentic" offer only reads documents better, it is IPA with a newer model.

Hyperautomation versus APA

Hyperautomation is the name of the programme: find processes with process mining, pick the technique per step, measure the result. APA is one of the techniques that programme can pick. A company can run hyperautomation with no agent in it, and can drop an agent into one process without any programme around it.

How the vendors package it

The products change every quarter, so the dates matter. UiPath made Maestro generally available on 30 April 2025 as a BPMN orchestrator for agents, robots and people, and its November 2025 release added case management and orchestration of other vendors' agents over MCP. Automation Anywhere has built its platform around the APA label since June 2024 and in May 2026 added AI evaluations at design and run time plus process simulation to test exceptions before go-live. Microsoft's Copilot Studio (documentation dated June 2026) keeps the two sides in separate objects: agent flows are deterministic and billed per action, agents use generative orchestration to choose which flows and tools to call, and a Power Automate cloud flow can be converted into an agent flow.

Pick the vendor for the systems you already run, and keep the process model in your own hands.

What changes in governance

Non-determinism. An agent task can take a different route on the same input tomorrow. Constrain it with structured outputs, an allowed outcome list, and a step budget, and treat any outcome outside the list as an escalation.

Run logs. An RPA log says which step ran. An agentic run log has to say which tools the agent called, in what order, what it saw and what reason it returned. Without that, the clerk cannot check the agent's work and an auditor cannot reconstruct it.

Eval sets for the agentic steps. A bot is tested by running it. An agent task is tested against past cases with a known right answer. UiPath's agent evaluations group such cases into evaluation sets, score them with exact-match or LLM-as-judge evaluators, and name around 30 evaluations as a benchmark for a usable agent score. Build that set from real historical exceptions before go-live and rerun it every time the prompt, the tools or the model version changes.

Spend. Bots cost licences; agents cost model calls per case, and a case that calls five tools costs several times a case that calls one. Copilot Studio meters every flow action and every trigger payload as consumption. Put a per-case cap in the process and follow the monthly bill per process.

What to watch out for with agentic process automation

Ask which steps the model decides. Gartner warned in June 2025 that vendors were relabelling RPA tools and chatbots as agents. The check is one question per step in the vendor's demo: is the next step chosen by a script or by a model? If the answer is "script" for every step, you are looking at RPA with a chat window; the AI washing and agent washing entry has the longer checklist.

Do not let the agent hold the process. The orchestrator holds state, timers and retries. An agent that also decides when the process is done has become an agent loop, and it should be priced and governed as one.

Start with one exception type. Give the agent the price-mismatch case and nothing else. Widen its outcomes once the eval set says it is right on the narrow case.

Keep the human tasks where the risk is. The agent's confidence is not the right trigger for a human task; the amount, the customer and the legal exposure are. Set those thresholds in the process model, where the process owner can see and change them.