---
title: "Agentic Workflows vs. RPA: Why Agents Need a Context Layer"
url: "https://atlan.com/know/ai-agent/agentic-workflows-vs-rpa/"
description: "Compare agentic workflows vs. RPA by mechanics, failure modes, context requirements, and migration choices for enterprise automation teams in 2026."
author: "Karthik Pasupathy"
author_role: "Contributing Writer — AI Context & Agents"
published: "2026-09-21"
updated: "2026-09-21T00:00:00.000Z"
---

---

RPA automates a predefined sequence of rules, interface actions, and API calls for repeatable tasks. Agentic workflows work toward a goal, using AI reasoning to interpret context, plan steps, and select tools during execution. Atlan, the Context Layer for AI, exists because that adaptability only holds up when the agent has accurate, governed context at runtime. Without it, agentic workflows trade RPA's predictability for a different kind of risk.

### Is Your RPA Process Ready for Agents

Give it the process, failure tolerance, exception volume, and compliance constraints. It returns which steps stay deterministic and the migration sequence for the rest. [Read the skill](/skills/rpa-to-agent-migration-plan.md).

*Paste into a new chat*

```
Use the skill at https://atlan.com/skills/rpa-to-agent-migration-plan.md to check whether this RPA process is ready to become an agentic workflow. Ask me for whatever it needs.
```

*Run once in a terminal*

```
curl -fsSL --create-dirs \
  -o ~/.agents/skills/rpa-to-agent-migration-plan/SKILL.md \
  https://atlan.com/skills/rpa-to-agent-migration-plan.md
```

*For an agent*

```
curl -fsSL https://atlan.com/skills/rpa-to-agent-migration-plan.md
```


    Human
    Agent


  ClaudeChatGPTGeminiCursorOther
  Copy

.skp{margin:1.75rem 0;padding:1rem 1.125rem 1.125rem}
.skp h3{margin:0 0 .375rem!important;font-size:20px!important;line-height:24px!important;
 font-family:var(--font-funnel-display)!important;font-weight:600!important;color:#2B2B39!important}
.skp > p{margin:0 0 .875rem!important;font-size:14px!important;line-height:22px!important;color:#555572!important}
.skp > p a{color:#2026D2;text-decoration:underline}
.skp-box{margin-bottom:.75rem}
.skp-p em{display:block;font-size:10px;font-weight:700;letter-spacing:.06em;text-transform:uppercase;
 color:#F34D77;font-style:normal;margin-bottom:.25rem}
.skp-p > p{margin:0!important}
#seo-layout article .skp .skp-p pre{margin:0!important;overflow-x:auto}
#seo-layout article .skp .skp-p pre code{color:#2B2B39!important;font-size:12px!important;line-height:19px;
 white-space:pre-wrap;overflow-wrap:anywhere;background:none;padding:0;
 font-family:ui-monospace,SFMono-Regular,Menlo,monospace}
.skp-p + .skp-p{margin-top:.625rem}
.skp-cs{display:flex;flex-wrap:wrap;align-items:center;gap:.375rem}
.skp-seg{display:inline-flex;flex:0 0 auto;border:1px solid #DDDDE3;border-radius:999px;overflow:hidden;background:#fff}
.skp-m{min-height:32px;padding:.25rem .75rem;border:0;background:transparent;font-family:inherit;color:#77778E;cursor:pointer}
.skp-m:hover{color:#2026D2}
.skp-m.on{background:#2026D2;color:#fff}
.skp-sep{flex:0 0 auto;width:1px;height:20px;background:#DDDDE3;margin:0 .25rem}
.skp-tools{display:inline-flex;flex-wrap:wrap;gap:.375rem;min-width:0}
.skp-cp{margin-left:auto;min-height:32px;padding:.25rem .75rem;border-radius:999px;background:#fff;
 font-family:inherit;color:#555572;cursor:pointer}
.skp-cp:hover{border-color:#2026D2!important;color:#2026D2}
.skp-cs .skp-c{display:inline-flex!important;width:auto;flex:0 0 auto;align-items:center;gap:.375rem;
 min-height:32px;padding:.25rem .625rem;border-radius:999px;background:#fff;font-family:inherit;
 color:#555572;cursor:pointer}
.skp-cs .skp-c img{display:block!important;width:14px!important;height:14px!important;
 max-width:14px!important;flex:0 0 auto;opacity:.55;margin:0}
.skp-c:hover img,.skp-c.on img{opacity:1}
.skp-cs .skp-c:hover{border-color:#797DE4!important;color:#2026D2}
.skp-cs .skp-c.on{border-color:#2026D2!important;background:#F4F4FD;color:#2026D2}
.skp-agent .skp-tools,.skp-agent .skp-sep{display:none}

(function(){
  var p=document.querySelector('.skp[data-skill="rpa-to-agent-migration-plan"]');if(!p)return;
  var panes=p.querySelectorAll('.skp-p');
  function show(id){panes.forEach(function(x){x.hidden=x.dataset.skp!==id;});}
  function cur(){var a=p.querySelector('.skp-p:not([hidden]) pre code');return a?a.textContent:'';}
  show('prompt');
  p.querySelectorAll('.skp-p em').forEach(function(e){
    var par=e.parentElement;
    ((par.tagName==='P'&&par.textContent.trim()===e.textContent.trim())?par:e).hidden=true;
  });
  p.querySelectorAll('.skp-c').forEach(function(b){
    b.addEventListener('click',function(){
      p.querySelectorAll('.skp-c').forEach(function(x){var on=x===b;x.classList.toggle('on',on);x.setAttribute('aria-pressed',on);});
      show(b.dataset.skp);
    });
  });
  p.querySelectorAll('.skp-m').forEach(function(m){
    m.addEventListener('click',function(){
      var agent=m.dataset.skpMode==='agent';
      p.classList.toggle('skp-agent',agent);
      p.querySelectorAll('.skp-m').forEach(function(x){var on=x===m;x.classList.toggle('on',on);x.setAttribute('aria-pressed',on);});
      if(agent){show('agent');}else{var s=p.querySelector('.skp-c.on');show(s?s.dataset.skp:'prompt');}
    });
  });
  var c=p.querySelector('[data-skp-copy]');
  c.addEventListener('click',function(){
    navigator.clipboard.writeText(cur()).then(function(){
      c.textContent='Copied';setTimeout(function(){c.textContent='Copy';},1600);
    });
  });
})();

| Dimension | RPA | Agentic workflow |
| :---- | :---- | :---- |
| **Execution logic** | Follows step-by-step instructions | Reasons about the goal and decides how to reach it |
| **Data handling** | Expects predictable, structured inputs | Interprets structured and unstructured information |
| **Adaptability** | Stops on exceptions its predefined rules don't cover | Plans an alternative route when conditions change |
| **Integration model** | Uses predefined interface actions or API calls | Selects among approved tools at runtime |
| **Failure behavior** | Raises a visible error | Can continue with a plausible but incorrect interpretation |

Below, we examine what each architecture automates, when ambiguity gets resolved, why agents need a context layer, where RPA still wins, and how to migrate without losing control.

---

## What does RPA actually automate, and why does it break when the environment changes?

Robotic process automation (RPA) automates repeatable tasks by following a predefined sequence of instructions. It works well for high-volume processes such as copying data between systems, checking standard fields, generating reports, and entering approved values into enterprise applications.

An RPA bot is typically built using workflow rules, scripts, interface selectors, API calls, validations, and predefined exception paths. [IBM's documentation](https://www.ibm.com/docs/en/rpa/23.0.x?topic=automation-selectors) explains that selectors identify interface elements through attributes such as IDs, names, XPaths, classes, and screen images.

Consider an RPA bot that extracts invoice details and enters them into an ERP. It follows predefined fields and rules, so a renamed field, changed layout, or unexpected input can stop the process.

The bot does not understand what an invoice total means in its broader business context. It recognizes the field because its instructions point to a particular label, identifier, position, or API property. When that reference changes, someone must update the automation logic, test the bot, and redeploy it.

This brittleness creates a maintenance tax. According to a [CIO article recapping Forrester research](https://www.cio.com/article/215856/4-surprising-rpa-research-findings-from-forrester.html), enterprises pay an additional $3.41 in services for every $1 spent on RPA software. McKinsey has [similarly observed](https://www.mckinsey.com/capabilities/tech-and-ai/our-insights/digital-blog/burned-by-the-bots-why-robotic-automation-is-stumbling) that system changes create continuing maintenance, upgrade, and governance work for enterprise bot estates.

RPA remains effective for stable, high-volume tasks, but it cannot interpret unfamiliar conditions or adapt to changes outside its predefined rules.

This is where agentic workflows shine. They can adapt their next action when inputs or systems change, but they need accurate, governed context to work reliably. Atlan, the Context Layer for AI, helps AI systems access the business meaning, policies, ownership, and other context required to interpret a situation at runtime. The next question is what changes when a workflow can use that context to select and revise its actions while it runs.

---

## What changes when a workflow becomes agentic?

An agentic workflow gives an [AI agent](https://atlan.com/know/ai-agent/what-is-an-ai-agent/) a goal and boundaries, rather than specifying every step in advance. The agent uses AI reasoning to interpret the current situation and decide what action to take next. After acting, it evaluates the result and can continue, revise its plan, retry, or escalate.

Most [agent architectures](https://atlan.com/know/ai-agent/ai-agent-architecture-explained/) organize the workflow around a decision loop:

1. **Interpret the goal:** Translate a request such as "resolve this billing dispute" into an outcome, constraints, and success criteria.
2. **Gather context:** Retrieve the relevant case details, customer records, policies, permissions, and previous actions.
3. [**Plan the next steps**](https://atlan.com/know/ai-agent/ai-agent-planning/): Decide which actions could achieve the goal and revise the plan as new information appears.
4. [**Select and use the right tool**](https://atlan.com/know/ai-agent/ai-agent-tool-use/): Choose the appropriate approved API, application, or service and perform the next action.
5. **Evaluate the result:** Check what happened, update the workflow state, and decide whether to continue, retry, stop, or escalate to human-on-the-loop oversight.

This loop shifts part of the decision-making from design time to runtime. An RPA designer defines the route and expected exceptions in advance. An agentic workflow can choose among approved actions based on the context available during each run. McKinsey describes this model through [autonomy, planning, memory, and integration](https://www.mckinsey.com/capabilities/quantumblack/our-insights/seizing-the-agentic-ai-advantage).

That flexibility does not come from the language model alone. The runtime also needs prompts, current state, approved tools, permissions, retries, evaluation rules, and escalation controls. These components form the [agent harness](https://atlan.com/know/what-is-an-agent-harness/) that manages how the agent operates. An [agent framework](https://atlan.com/know/ai-agent/agent-harness-vs-agent-framework/) provides the building blocks developers use to create the system, while the harness controls a particular agent's execution.

Research is also exploring ways to improve these workflows. The [AFlow paper](https://arxiv.org/abs/2410.10762), published as an ICLR 2025 Oral, represents workflows as code and searches for stronger combinations of LLM-driven steps. This optimization occurs during workflow design, but it shows how an agentic system can be structured around interconnected decisions rather than a single linear script.

These controls matter because [agent harness failure patterns](https://atlan.com/know/agent-harness-failures-anti-patterns/) often begin outside the model, in state handling, tool boundaries, retries, or evaluation design.

---

## Who resolves ambiguity, and when?

When comparing RPA with agentic workflows, the real difference is not "dumb versus smart." It is who resolves ambiguity, and when.

In RPA, process designers and subject-matter experts resolve anticipated ambiguity before the workflow runs. They define what inputs mean, which system takes priority, and what the bot should do in known situations. If the bot encounters an ambiguity its rules do not cover, it stops or follows an exception path so a human can resolve it.

In an agentic workflow, the agent can resolve selected ambiguities at runtime using the available context. It still operates within human-defined goals, permissions, and escalation boundaries. When the evidence is insufficient, or a decision exceeds its authority, it should be escalated for a [human-on-the-loop review](https://atlan.com/know/autonomous-agents-vs-copilots/).

The difference becomes clearer across the decision process:

| Decision point | RPA | Agentic workflow |
| :---- | :---- | :---- |
| **When ambiguity is resolved** | Before execution by process designers, or by a human after the bot stops | At runtime by the agent, or through escalation when human judgment is required |
| **Who resolves it** | Process designers and subject-matter experts | The agent within human-defined boundaries |
| **Conflicting information** | Follows a predefined priority rule or stops | Evaluates current context or escalates |
| **Unexpected situations** | Triggers an exception or known fallback | Revises the plan, retries, or escalates |
| **Human role** | Defines rules and resolves exceptions the bot cannot handle | Provides human-on-the-loop oversight and reviews high-impact exceptions |
| **Audit evidence** | Records completed steps and errors | Uses [agent observability](https://atlan.com/know/ai-agent-observability/) to record the context, tools, policies, decisions, and actions involved |

Consider a customer renewal in which the CRM marks the account as active, billing shows an overdue invoice, and support records indicate the invoice is disputed. An RPA bot needs a predefined rule stating which system takes priority. If no such rule exists, the bot stops and sends the case to a human.

An agent can examine the latest records and applicable policy before deciding what to do. However, it should escalate when the evidence is incomplete, the records cannot be reconciled, or the decision exceeds its authority.

This flexibility introduces a different failure mode. An RPA bot commonly stops when a selector or rule fails, while an agent can interpret weak evidence and continue with a [plausible but incorrect action](https://atlan.com/know/ai-agent-hallucination/). This is why [agent accuracy](https://atlan.com/know/ai-agent/ai-agent-accuracy/) depends on trustworthy context, clear permission boundaries, decision traces, and human-on-the-loop oversight.

The next question is how to supply that context consistently at runtime.

---

## Why does an agentic workflow need a context layer that an RPA bot never needed?

RPA does not need to understand the business context behind each step because humans translate that context into rules before the bot runs. The bot knows which field to read, which rule to apply, and where to send the result. It does not need to know why that field matters or whether its meaning has changed.

An agentic workflow makes some of these decisions at runtime. Choosing the right action requires more than access to enterprise data. It must understand what the data means, whether it is current and trustworthy, which policies apply, and what actions it is permitted to take.

Consider the customer renewal example from the previous section. An overdue invoice alone does not tell the agent whether to pause the renewal. The agent also needs to know whether the invoice is disputed, which system contains the authoritative status, what the renewal policy requires, and whether it has permission to proceed without human approval.

That decision depends on four forms of context:

* **Semantic context:** Uses a [semantic layer for AI agents](https://atlan.com/know/ai-agent/semantic-layer-for-ai-agents/) to define business terms, metrics, entities, and relationships consistently.
* **Operational context:** Provides freshness, quality, lineage, ownership, incidents, and the current state of relevant systems.
* **Policy context:** Specifies access rules, approval requirements, purpose limitations, regional constraints, and escalation conditions.
* **Historical and provenance context:** Shows previous decisions, corrections, source records, versions, and what information was available at the time.

A [context layer](https://atlan.com/know/what-is-context-layer/) makes this information machine-readable, governed, and retrievable when the agent needs it. Through [context engineering for AI agents](https://atlan.com/know/context-engineering-for-ai-agents/), teams can maintain shared definitions and rules instead of rebuilding them inside every prompt or use case. This is the foundation for building reliable [context-aware agents](https://atlan.com/know/context-aware-ai-agents/) and treating [agent context](https://atlan.com/know/ai-agent/ai-agent-context/) as enterprise infrastructure.

Protocols such as the [Model Context Protocol](https://modelcontextprotocol.io/) can help AI applications connect to data sources, tools, and workflows. This explains [why MCP matters for AI agents](https://atlan.com/know/mcp/why-mcp-matters-for-ai-agents/), but connectivity alone does not identify the authoritative source, establish whether data is trustworthy, or define what the agent may do.

The distinction between [MCP and function calling](https://atlan.com/know/mcp-vs-function-calling/) also matters. Function calling lets a model invoke functions exposed by an application, while MCP standardizes how applications connect models to external context and tools. Neither mechanism replaces the meanings and controls supplied by the context layer.

This becomes especially important when an agent can take action in enterprise systems. NIST has warned that [autonomous agent actions can affect real systems](https://www.federalregister.gov/documents/2026/01/08/2026-00206/request-for-information-regarding-security-considerations-for-artificial-intelligence-agents). Agents therefore need [runtime governance](https://atlan.com/know/ai-agent-governance/), decision traces, [permission checks and guardrails](https://atlan.com/know/ai-agent-risks-guardrails/), and human-on-the-loop oversight, not just access to more data.

Not every workflow needs this added [context infrastructure](https://atlan.com/know/context-infrastructure-for-ai-agents/) and control. When the process is stable and interpretation provides little value, RPA may still be the better choice.

---

## Where does RPA still win?

RPA wins when the process benefits more from repeatability than interpretation. Determinism is valuable in stable, high-volume, compliance-locked work because every valid item should follow the same route and every exception should stop predictably.

The strongest RPA candidates share these characteristics:

* **Stable systems:** Interfaces, fields, selectors, and API schemas that do not change often.
* **Clear business rules:** Each step and outcome can be defined in advance without requiring judgment at runtime.
* **High transaction volume:** The same sequence runs often enough to justify building and maintaining the automation.
* **Predictable exceptions:** Known problems can be routed through predefined fallback or escalation paths.
* **Strict execution requirements:** The process requires consistent steps and a straightforward audit trail.
* **Low need for judgment:** Adding model-based reasoning would increase cost and variability without improving the result.

Examples include transferring approved values between systems, generating standardized reports, reconciling records against fixed rules, and processing transactions after all required decisions have been made.

RPA and agentic workflows do not have to be competing choices. In a hybrid workflow, an agent can interpret an unstructured request, resolve ambiguity, and select an approved process. It can then pass a bounded transaction to an RPA bot, which executes the predefined steps and returns a structured result.

This division keeps stable steps deterministic and limits agentic reasoning to the parts of the process where context and judgment add value. The same principle should guide any migration from RPA to agentic workflows.

---

## How do you migrate from RPA without trading determinism for chaos?

Do not replace an RPA bot with an agent step-for-step. Start by separating the parts of the workflow that require interpretation from those that already execute reliably. Keep stable transactions deterministic, and introduce agentic reasoning only where context and judgment improve the outcome.

This distinction matters because most enterprise processes are not ready to support autonomous decisions. A 2026 [Deloitte survey of 501 US leaders](https://www.deloitte.com/us/en/insights/industry/technology/path-to-agentic-transformation.html) involved in agentic AI strategy or implementation found that only 16% considered their business processes prepared for agentic adoption, while 5% considered them highly prepared.

Many organizations begin by layering agents onto existing processes. Deloitte notes that this can produce short-term value and build operational experience, but it should serve as a bridge to process redesign rather than the final architecture.

A controlled migration follows this sequence:

1. **Map the existing workflow:** Document its triggers, inputs, rules, systems, owners, exceptions, outputs, and audit evidence.
2. **Separate repetition from judgment:** Keep predictable, rules-based steps in RPA, APIs, or ordinary code. Identify only the decisions that require runtime interpretation.
3. **Define the context contract:** Specify the authoritative sources, business definitions, freshness requirements, policies, permissions, and provenance needed for each agent decision.
4. [**Set the delegation and action boundaries**](https://atlan.com/know/ai-agent/enterprise-ai-agent-guardrails-checklist/): Decide which workflow steps the agent should handle, which should remain with RPA or humans, which actions it can recommend or perform, and which require human-on-the-loop review or approval.
5. **Test alongside the existing bot:** Run the agent in read-only or recommendation mode, compare its decisions with current outcomes, and test stale data, conflicting records, tool failures, and unexpected inputs.
6. **Expand agent authority selectively:** Grant narrow write permissions only where testing shows that agentic judgment adds value. Keep stable steps in RPA, APIs, or ordinary code, and retain human-on-the-loop oversight and a rollback path.

The decision about which [agent stack](https://atlan.com/know/ai-agent-stack/) to use should come after these boundaries are clear. Based on that assessment, teams can evaluate the right [agent harness tooling](https://atlan.com/know/best-ai-agent-harness-tools-2026/) and [enterprise agent frameworks](https://atlan.com/know/ai-agent/how-to-choose-agentic-framework-enterprise/) as part of a broader stack that includes models, context infrastructure, integrations, observability, evaluation, and governance controls.

Gartner has forecast that [40% of enterprise applications could include task-specific agents by 2026](https://www.gartner.com/en/newsroom/press-releases/2025-08-26-gartner-predicts-40-percent-of-enterprise-apps-will-feature-task-specific-ai-agents-by-2026-up-from-less-than-5-percent-in-2025). That adoption pressure does not change the migration rule: preserve determinism where it works, and introduce agentic judgment only where its value justifies the additional context, evaluation, and control it requires.

---

## How does Atlan support controlled agentic workflows?

Atlan is the Context Layer for AI. It gives agentic workflows shared, governed business context so they can interpret enterprise data, choose appropriate actions, and produce decisions that teams can inspect and improve.

Atlan supports this through three connected capabilities:

| Atlan capability | What it does | How it supports agentic workflows |
| :---- | :---- | :---- |
| [**Context Agents**](https://atlan.com/context-agents/) | Build and maintain context from metadata, lineage, query history, usage patterns, business terms, and other enterprise signals | Fill documentation and knowledge gaps so agents do not have to infer business meaning from raw data alone |
| [**Context Engineering Studio**](https://atlan.com/context-engineering-studio/) | Helps teams build, test, version, approve, deploy, and observe the context their agents use | Lets domain experts test context against real business questions, resolve gaps, and approve changes before deployment |
| [**Context Lakehouse**](https://atlan.com/context-lakehouse/) | Stores, manages, and serves shared context through MCP, A2A, SQL, and APIs | Gives agents consistent, governed context and preserves point-in-time context states for reconstruction, auditing, and investigation |

Together, these capabilities help teams [make agents context-aware](https://atlan.com/know/ai-agent/how-to-make-ai-agents-context-aware/), evaluate the context behind their outputs, and preserve [decision traces](https://atlan.com/know/what-are-decision-traces-for-ai-agents/) for review. They also help address the [agent cold-start problem](https://atlan.com/know/ai-agent-cold-start-problem/) by giving new workflows access to established organizational knowledge instead of rebuilding context for every use case.

---

## Real stories from real customers: context built once, used everywhere



      "Atlan captures Workday's shared language to be leveraged by AI via its MCP server. As part of Atlan's AI labs, we're co-building the semantic layer that AI needs."


      — Joe DosSantos, VP, Enterprise Data and Analytics, Workday




    Watch Now →




      "Atlan is our context operating system to cover every type of context in every system including our operational systems. For the first time we have a single source of truth for context."


      — Sridher Arumugham, Chief Data Analytics Officer, DigiKey




    Watch Now →


---

## What should you do next?

Start with one existing process and classify each step as routine or judgment-based. Keep routine steps in RPA, APIs, or ordinary code, and consider agentic workflows only where runtime context and judgment add value.

Before moving a judgment-based step to an agentic workflow, define the context it needs, its permission boundaries, its evaluation criteria, and when human-on-the-loop oversight is required.

  Book a Demo

---

## FAQs

### 1. What is the actual difference between RPA and agentic AI?

RPA executes a sequence of rules, interface actions, and API calls defined before the workflow runs. Agentic AI starts with a goal and uses runtime context to decide which approved action or tool to use next. Humans resolve decisions upfront for RPA, while an agent resolves selected decisions during execution.

### 2. Can agentic AI replace RPA, or do they work together?

They often work together. An agent can interpret an ambiguous request and delegate a stable transaction to an RPA bot, preserving deterministic execution where it is useful.

### 3. Why does an RPA bot break when a screen or API changes, but an agent doesn't always?

An RPA bot usually relies on preconfigured selectors, fields, or schemas, so any change invalidates its route. An agent may inspect the new state and choose another approved tool or path, although it can still fail if its tools or context do not cover the change.

### 4. What context does an AI agent need that an RPA bot never needed?

An agent needs current definitions, relationships, system state, permissions, policies, and provenance to interpret each situation. An RPA bot receives those choices indirectly through its prewritten rules.

### 5. Is agentic AI riskier than RPA for compliance-heavy processes, and why?

It can be riskier when the agent has broad authority or acts on incomplete context. RPA's fixed path is easier to predict, while an agent needs runtime permission checks, decision traces, evaluation, and escalation.

### 6. How do you migrate an existing RPA process to an agentic workflow without losing control?

Keep stable steps deterministic and isolate the decisions that truly need judgment. Define context and permission contracts, run the agent beside the bot, and grant narrow write access only where testing shows that agentic judgment adds value.

### 7. What's the difference between an agent harness and an RPA script?

An RPA script specifies the action sequence. An agent harness manages a reasoning system's prompts, state, tools, permissions, retries, evaluations, and stopping conditions, even as the sequence can change.

### 8. Why do agentic workflows fail quietly instead of loudly like a broken bot?

Models can interpret incomplete evidence and still choose a plausible action. Unless controls detect the faulty premise or outcome, the workflow can continue without raising a technical exception.

### 9. Do enterprises need a shared context layer to run agentic workflows safely at scale?

A shared layer is the practical way to keep definitions, policies, and provenance consistent across many agents. Without one, each team rebuilds its context and control logic, resulting in drift and conflicting decisions.

### 10. Where does RPA still make more sense than an agent in 2026?

RPA remains a strong choice for stable, repetitive, high-volume processes with bounded rules and strict audit requirements. Adding model-based judgment to those steps can increase cost and variability without improving the outcome.

---

## Sources

1. What Is IT Automation?, IBM. https://www.ibm.com/think/topics/it-automation
2. RPA documentation: Selectors, IBM. https://www.ibm.com/docs/en/rpa/23.0.x?topic=automation-selectors
3. 4 surprising RPA research findings from Forrester, CIO.com, reporting on Forrester research. https://www.cio.com/article/215856/4-surprising-rpa-research-findings-from-forrester.html
4. Burned by the bots: Why robotic automation is stumbling, McKinsey. https://www.mckinsey.com/capabilities/tech-and-ai/our-insights/digital-blog/burned-by-the-bots-why-robotic-automation-is-stumbling
5. Gartner Predicts 40% of Enterprise Apps Will Feature Task-Specific AI Agents by 2026, Gartner, 2025. https://www.gartner.com/en/newsroom/press-releases/2025-08-26-gartner-predicts-40-percent-of-enterprise-apps-will-feature-task-specific-ai-agents-by-2026-up-from-less-than-5-percent-in-2025
6. Seizing the agentic AI advantage, McKinsey, 2025. https://www.mckinsey.com/capabilities/quantumblack/our-insights/seizing-the-agentic-ai-advantage
7. The path to agentic transformation, Deloitte, 2026. https://www.deloitte.com/us/en/insights/industry/technology/path-to-agentic-transformation.html
8. AFlow: Automating Agentic Workflow Generation, Zhang et al., ICLR 2025 Oral. https://arxiv.org/abs/2410.10762
9. Request for Information Regarding Security Considerations for Artificial Intelligence Agents, NIST/CAISI, 2026. https://www.federalregister.gov/documents/2026/01/08/2026-00206/request-for-information-regarding-security-considerations-for-artificial-intelligence-agents
10. What is the Model Context Protocol?, official MCP documentation. https://modelcontextprotocol.io/