The Iron Cage as Cradle: The Counter-Intuitive Symbiosis of Rigid ERP Systems and Agentic AI

Summary

The history of enterprise resource planning (ERP) systems, particularly those architected by SAP, has been dominated by a narrative of necessary friction. For decades, organizations have grappled with the "Iron Cage" of SAP’s architecture: a landscape defined by unyielding data structures, unforgiving validation logic, and an authorization concept so granular that it frequently impedes human agility. The prevailing industry dogma has viewed these characteristics as liabilities—technical debt incurred in the pursuit of integration, resulting in high training costs, "swivel-chair" interfaces, and a user experience often characterized by frustration. Corporations have spent billions on change management and overlay interfaces to shield human operators from the raw, deterministic complexity of the core system.

However, as the enterprise technology landscape pivots violently toward the era of Agentic Artificial Intelligence (AI), a profound inversion of value is occurring. The very characteristics that made SAP environments hostile to human cognitive limitations—strict constraints, hyper-granular Role-Based Access Control (RBAC), and blocking validation errors...are transforming into the ideal substrate for autonomous AI agents.¹

This report advances a counter-intuitive thesis: the "hard to run" nature of SAP ERPs constitutes a necessary breeding ground for safe, reliable, and effective Agentic AI. Unlike generative AI operating in unstructured environments—often described as building "floating castles in thin air"—agents within an SAP ecosystem operate within a deterministic physics engine. This rigid structure provides the "grounding" necessary to prevent hallucination, the "signals" necessary for orchestration, and the "boundaries" necessary for security.

The following analysis exhaustively explores this symbiosis. It details how the administrative burden of the Profile Generator (PFCG) becomes a zero-trust security framework for "Micro-Agents." It demonstrates how process friction acts as a precise communication protocol between Master Agents and Sub-Agents. It argues that the ABAP Dictionary’s strict typing serves as an immutable guardrail against generative error. Finally, it maps the technical architecture of the SAP Business Technology Platform (BTP), SAP Joule, and the Knowledge Graph, illustrating how these components operationalize the rigorous, structured legacy of SAP into a dynamic, ...autonomous future.²

1. The Inversion of Usability: From User Experience to Agent Experience

The evolution of enterprise software has traditionally tracked the trajectory of consumer software: a relentless pursuit of "ease of use." The metric of success was the reduction of friction for the human user. "Intuitive" design meant hiding complexity, broadening access, and smoothing over the rough edges of database integrity with helpful wizards and forgiving inputs. In the context of SAP, this drive led to the development of SAP Fiori and numerous simplified GUIs intended to mask the underlying complexity of transaction codes like VA01 (Create Sales Order) or ME21N (Create Purchase Order).

In the emergent era of Agentic AI, the design paradigm must shift from User Experience (UX) to Agent Experience (AX). Agents, unlike humans, do not benefit from ambiguity or "forgiveness." They thrive on explicit constraints, structured error messages, and deterministic pathways. The "hard" nature of SAP—its refusal to accept a transaction unless every master data field is perfectly aligned—is precisely what makes it an effective environment for agents.³

1.1 The Deterministic Substrate for Probabilistic Intelligence

Generative AI, driven by Large Language Models (LLMs), is inherently probabilistic. These models function by predicting the next token in a sequence based on statistical likelihood derived from vast training corpora. While this allows for unprecedented flexibility and "reasoning" capabilities, it introduces the critical risk of "hallucination" or "confabulation."⁴ In a creative context, a hallucination is a curiosity; in an enterprise ledger, it is a compliance violation or financial fraud.

When probabilistic agents are introduced into an enterprise environment, they require a deterministic substrate to function safely. SAP acts as this substrate. It functions as a physics engine for business reality. Just as a robot in a physical simulation relies on gravity and collision detection to learn to walk, an AI agent in SAP relies on validation logic and foreign key checks to learn to transact.

If an AI agent attempts to invent a new "Incoterm" that sounds plausible (e.g., "FOB Moon Base"), a flexible system might accept it as a text string. SAP, however, will reject it immediately because it does not exist in table TINC. This rejection is not a failure of the system; it is a successful containment of probabilistic error. The "hardness" of the system provides the negative feedback loop required for the agent to self-correct and learn.

1.2 System 1 vs. System 2 in the Enterprise

Cognitive science distinguishes between System 1 thinking (fast, intuitive, heuristic) and System 2 thinking (slow, deliberate, logical.⁵ Humans are naturally System 1 thinkers who struggle with the System 2 demands of complex ERP transactions. We forget codes, we misread fields, and we bypass protocols to "get it done."

Traditional ERP implementations forced humans to act like System 2 machines, causing massive friction. Agentic AI, specifically architecture that utilizes "Chain of Thought" reasoning, mimics System 2 logic but operates at the speed of software. By coupling Agentic AI with SAP, the enterprise achieves a cognitive hybrid:

• The Agent provides the adaptive planning, intent understanding, and unstructured data processing (System 1 flexibility).
• The ERP Core provides the immutable logic, regulatory boundaries, and financial integrity (System 2 rigor).

This report posits that the decades of investment companies have made in configuring their SAP systems—defining every tolerance limit, every plant parameter, every pricing procedure—is not a sunk cost of legacy debt. Rather, it is pre-investment in the "World Model" required for autonomous agents to function. Without this rigorous World Model, agents are merely chatbots with no understanding of consequence.

2. The Architecture of Restriction: Granular Roles as a Zero-Trust Framework

The first pillar of the core thesis rests on the granularity of SAP’s authorization concept. Security in SAP is not merely a gate; it is a complex lattice of permissions managed via the Profile Generator (PFCG). Access is controlled not just by transaction code, but by the content of the data itself via Authorization Objects.

2.1 The Legacy Challenge: The Human Authorization Paradox

Implementing the Principle of Least Privilege in a human-centric SAP environment has historically been a Sisyphean task. The system allows administrators to restrict access down to specific organizational units (e.g., Sales Org US01), document types (e.g., Sales Order ZOR), and activities (e.g., 01 for Create, 03 for Display).

However, managing this level of granularity for thousands of human employees is administratively crushing.

• Availability: There are rarely enough humans to dedicate specific individuals to hyper-narrow roles (e.g., "Dallas Retail Sales Order Clerk"). Instead, a single "Sales Rep" covers multiple regions and channels.
• Psychology: Humans react negatively to authorization errors. A "Not Authorized" message SU53 is viewed as an impediment to doing one's job. It generates helpdesk tickets, frustration, and eventual "role creep," where administrators grant wider access (e.g., Sales Org *) just to silence the complaints.⁶

Consequently, most SAP environments today operate with "Composite Roles" that are vastly over-provisioned relative to the strict needs of any single transaction. This creates a security surface area that is vulnerable to insider threat and error.

2.2 The Agentic Opportunity: The Rise of the Micro-Agent

Agentic AI inverts this dynamic. An AI agent does not get frustrated. It does not suffer from "alert fatigue." It does not require a "broad" role to function comfortably. This allows for the implementation of a Zero Trust Architecture for agents using Micro-Agents.

In this model, a general-purpose "Master Agent" (e.g., SAP Joule) acts as the interface. When a complex request arrives—"Book a sales order for a retail customer in Dallas"—the Master Agent does not execute the transaction itself. Instead, it instantiates or calls a specialized "Dallas Retail Sales Order Agent."

Anatomy of a Micro-Agent:
This sub-agent is a specialized identity (or a session context via Principal Propagation) that possesses an SAP Role (PFCG) restricted to the absolute minimum viable privileges:

• Object V_VBAK_VKO:
  • Sales Org: US01 (North America)
  • Distribution Channel: 01 (Retail)
  • Division: 00
• Object V_VBAK_AAT:
  • Document Type: ZOR (Standard Order)
• Object M_MATE_WRK:
  • Plant: DL01 (Dallas)

If this agent attempts to book an order for the Wholesale channel (02), the SAP kernel blocks the transaction immediately. The "hard" security model acts as a physical containment field. In a human scenario, this block is a process failure. In an agentic scenario, this is a valid negative test. It confirms that the agent is operating within its guardrails.⁶

2.3 Dynamic Role Resolution and Principal Propagation

The technical realization of this involves sophisticated identity management.⁷ The research highlights Principal Propagation as a critical mechanism on the SAP Business Technology Platform (BTP).⁸

When a human user interacts with an AI agent, the agent must not operate with a "Super User" service account. It must inherit the context of the human user. Through the SAP Cloud Connector and BTP Connectivity service, the user's identity is propagated to the backend SAP S/4HANA system. The agent effectively "becomes" the user for the duration of the transaction.

• Benefit: The agent is instantly constrained by the user's existing PFCG roles. If the user cannot approve a PO over USD10,000, neither can their AI assistant.
• Risk Mitigation: This prevents "jailbreaking" attacks where a user might convince an LLM to bypass business rules. The LLM might agree, but the backend SAP kernel will refuse the commit.

For autonomous, "headless" agents (e.g., nightly batch repair bots), the system uses specific Technical Users with highly restricted roles. The "hard to run" aspect of defining these roles—the need to map out every authorization object—ensures that these autonomous bots have no lateral movement capability. If a "Price Update Bot" is compromised, it cannot read HR data because it fundamentally lacks the authorization object P_ORGIN.⁹

2.4 Table: Comparison of Authorization Paradigms

3. Friction as Signal: Streamlining Business Processes via Orchestration

The second pillar of the thesis addresses the friction inherent in implementing business processes in SAP. In traditional operations, "friction" is synonymous with "exception" or "error." An order is blocked because a credit check failed. An invoice is parked because of a price variance. A shipment is delayed because the material master view is missing for the destination plant.

3.1 The Cost of Human Latency

For human agents, these exceptions are productivity killers. Consider the scenario where a sales agent attempts to book an order, only to find the customer is not extended to the specific Sales Area.

1. Stop: The transaction fails.
2. Search: The agent must figure out why (deciphering error VP 204).
3. Identify: The agent must find who owns Customer Master Data.
4. Communicate: The agent sends an email or logs a ticket.
5. Wait: The process enters a holding pattern, often for days ("Most of the time they don't even know who to call").¹⁰

This latency destroys process efficiency. The rigidity of the system—the requirement that the customer must be extended before the order can be saved—is the bottleneck.

3.2 The Agentic Orchestration Layer

In an Agentic AI ecosystem, this friction is re-contextualized. The blocking error is not a "stop" signal; it is a functional specification for a remediation workflow. The "hard" constraint becomes a trigger for multi-agent orchestration.

Scenario: The "Missing Master Data" Handoff

1. Sales Order Agent (Micro-Agent A) attempts to create an order via OData API API_SALES_ORDER_SRV.
2. SAP Kernel returns error: Customer 1000 is not defined in Sales Area US01/10/00.
3. Sales Order Agent parses this error. Unlike a human who sees "failure," the agent sees a dependency.
4. Orchestration: The Sales Agent packages this error context and routes a request to the Master Data Agent (Micro-Agent B).
   • Prompt/Payload: "I need to transact with Customer 1000 in Area US01/10/00. Please extend."
5. Master Data Agent receives the request.
   • It checks the Governance Policy (via RAG on policy documents).
   • It validates the customer's credit standing.
   • It executes the extension via API API_BUSINESS_PARTNER.
   • It returns a "Success" signal to the Sales Agent.
6. Sales Order Agent retries the transaction. Success.

This entire sequence occurs in seconds. The "ball keeps rolling" without human intervention. The rigidity of the SAP system—the fact that it threw a specific, blocking error—provided the precise signal needed for the agentic handoff. If the system were "easier" (i.e., allowed the order to proceed with incomplete data), it would create downstream chaos in fulfillment and billing. The "hardness" forces resolution upstream, where agents are most effective.¹¹

3.3 Multi-Agent Systems (MAS) and Departmental Agents

This logic extends to complex inter-departmental workflows. The research identifies specific agent roles such as the Dispute Resolution Agent, Cash Collection Agent, and Sourcing Agent.¹¹

These agents form a Multi-Agent System (MAS) that mirrors the organizational chart but operates with high-speed digital interconnects.

• The "Finance Agent" and "Sales Agent" negotiate credit blocks. When a Sales Agent requests a credit release, the Finance Agent analyzes the customer's payment history (using vector analysis of past interactions) and autonomously decides whether to grant a temporary override via transaction VKM1.
• The "Sourcing Agent" and "Planning Agent" collaborate on inventory shortages. If the Planning Agent detects a stock-out (MD04 signal), the Sourcing Agent autonomously initiates an RFP process for the specific material.¹²

The "friction" of the departmental silos—enforced by the distinct SAP modules (FI, SD, MM)—becomes the protocol for agent negotiation.

4. The Hallucination Firewall: Validation Logic as Reality Check

The third pillar concerns the core philosophy of SAP: Data Integrity. SAP is built on the premise that it is better to stop a process than to corrupt the database. This "NEVER let a wrong entry hit the database" philosophy is the single most important safety feature for deploying Generative AI in the enterprise.

4.1 The Existential Risk of AI in ERP

Generative AI is prone to "hallucinations"—generating plausible but incorrect information. In a chat application, a hallucination might be a made-up fact. In an ERP system, a hallucination could be:

• Posting an invoice to a non-existent General Ledger account.
• Inventing a unit of measure (e.g., "Box" instead of "Case").
• Creating a delivery for a date in the past.

If an AI agent were given direct SQL write access to the database, it could corrupt the financial integrity of the organization in milliseconds.

4.2 The ABAP Dictionary as a Constraint Engine

In SAP, the ABAP Dictionary (DDIC) and the application logic act as an immutable constraint engine. An agent cannot book an invoice to a non-existent cost center because the foreign key check against table CSKS will fail. It cannot enter a date in the past if the posting period (OB52) is closed.

These validations act as a Hallucination Firewall.

• Three-Way Match: If an Accounts Payable Agent tries to post an invoice for USD1000 when the PO was for USD900, the SAP system blocks the posting (Price Variance > Tolerance Limit).
• Behavioral Correction: This block serves as a feedback signal. The agent learns that its "belief" (that the invoice should be paid) conflicts with "reality" (the system rules). This forces the agent into a Reflection Loop: "Why did I fail? Variance detected. Action: Park invoice and notify human."

This architecture ensures that the AI handles the "Happy Path" (perfect matches), while the strict validation logic filters out the hallucinations and edge cases for human review.

4.2.1 The Rust Compiler Analogy: Unforgiving Logic as Self-Correction

Just as the Rust compiler (specifically the borrow checker) refuses to compile code that violates memory safety rules, the SAP Kernel (specifically the ABAP Dictionary and Business Object logic) refuses to commit transactions that violate business integrity rules. Here is why this analogy holds up technically, and how this "unforgiving" nature forces the AI to self-correct:

• The "Compiler" as a Reality Check: In Rust, the compiler prevents memory corruption. In SAP, the validation logic prevents ledger corruption. For an AI agent, the system returns a binary signal: Success or Hard Stop. This forces the AI to remain "hallucination-free by design."
• Error Messages as "Compiler Errors" for Agents: The AI agent reads a system error code (e.g., VP 204 - Customer not defined) not as a failure, but as a prompt to trigger a correction, such as calling a "Create Customer" tool.
• "Check Mode" = "Dry Run": SAP BAPIs often feature a Test Run or Simulation Mode. Agents can "compile" their transaction in simulation mode to see if it would pass, fixing errors iteratively before writing to the real database.
• Real-World Convergence: SAP is actually using Rust: For Joule for Developers, SAP uses Constrained Decoding backed by a Rust parser to ensure the AI generates valid ABAP code, confirming the industry's use of "unforgiving compilers" as guardrails.

Summary

The mechanism is correctly identified as Neuro-symbolic AI:

• The Neural part (The AI): Provides the flexibility, intent understanding, and planning.
• The Symbolic part (Rust/SAP): Provides the hard constraints, logic, and "unforgiving" validation.

This combination ensures that the AI can be autonomous but never dangerous.

4.3 Human-in-the-Loop (HITL) by Design

The thesis highlights that "failure to process is a flag to bring in human expert." This operationalizes the Human-in-the-Loop concept not as a constant monitor, but as an Exception Handler.

When the AI hits a "hard stop" in SAP that it cannot resolve via its tools (e.g., a strategic decision to pay a vendor despite a discrepancy to maintain the relationship), it escalates. The human expert receives a structured task: "Agent blocked by Price Variance (USD100). Do you wish to override?"

This elevates the human role from data entry to strategic arbitration. The "hard" system ensures that the AI never acts autonomously in ambiguous or erroneous states.¹³

5. Grounding the Ghost: Structured Data and the SAP Knowledge Graph

The fourth pillar addresses the data itself. "Companies trying to implement Agentic AI without well-grounded ERP are trying to build floating castles in thin air." AI models require context to reason. Unstructured data (emails, PDFs) provides semantic richness but lacks structural integrity. SAP provides the structural skeleton of the enterprise.

5.1 The SAP Knowledge Graph

To make this structural richness accessible to AI, SAP has introduced the SAP Knowledge Graph.¹⁴

• The Problem: LLMs speak natural language. SAP speaks "technical codes" (Tables MARA, KNA1, BKPF). An LLM does not inherently know that KUNNR is a Customer Number or that a Sales Order Item connects to a Delivery Item via the Document Flow table VBFA.
• The Solution: The Knowledge Graph creates a semantic layer that maps technical entities to business concepts. It encodes the relationships: Customer --places--> Order --contains--> Material.

This "grounds" the AI. When an agent is asked, "Check the status of the order for Dallas," it doesn't guess. It traverses the graph: Customer(Dallas) -> SalesOrder -> Delivery -> GoodsIssue. This deterministic traversal prevents the agent from hallucinating relationships that don't exist.

5.2 Vector RAG and the HANA Vector Engine

SAP HANA Cloud’s Vector Engine enables Retrieval-Augmented Generation (RAG) that combines structured and unstructured data.¹⁵

• Structured Grounding: "Show me quality defects for Material X" (SQL Query to QMEL table).
• Unstructured Grounding: "Show me complaints where the customer mentioned 'strange smell'" (Vector search on text descriptions).

The combination allows agents to reason with high precision: "I found 5 complaints about 'smell' (Unstructured). All 5 are linked to Batch #992 (Structured). Conclusion: Batch #992 is defective."
Without the rigid link between the Complaint Notification and the Batch Record provided by the SAP data model, this correlation would be impossible to establish with certainty. The "hard" structure enables the "smart" reasoning.

6. The Technical Stack: Architecture of the Agentic Enterprise

To realize this thesis, organizations must deploy a specific technical architecture centered on the SAP Business Technology Platform (BTP). This stack bridges the gap between the rigid core and the fluid agent.

6.1 SAP Joule and the Orchestration Layer

SAP Joule serves as the primary interface and orchestrator.¹⁶ It is not merely a chatbot; it is a runtime environment that manages:

• Intent Recognition: Mapping user prompts to specific skills.
• Context Management: Keeping track of the session variables (e.g., "We are talking about Sales Order 123").
• Agent Dispatch: Routing tasks to the appropriate specialized agents (e.g., triggering the Cash Collection Agent).

6.2 Joule Studio and the Agent Builder

Joule Studio allows for the creation of custom agents using the Agent Builder.¹⁷ This low-code environment enables developers to define:

• Capabilities: What tools the agent can use (e.g., OData Service: API_PURCHASE_ORDER).
• Triggers: What events wake the agent up (e.g., Event Mesh: InvoiceCreated).
• Guardrails: What the agent is not allowed to do.

6.3 Connectivity: Model Context Protocol (MCP) and Headless Agents

A critical innovation is the Model Context Protocol (MCP).¹⁸ This protocol allows SAP agents to interact with external systems and tools in a standardized way.

• Use Case: An SAP agent needs to check a shipping rate from a logistics provider. Instead of a hard-coded interface, it uses an MCP server to query the provider dynamically.
• Headless vs. GUI Agents: The research distinguishes between two modes of agent operation:
  • API-Based (Headless) Agents: These communicate via OData/REST APIs. They are fast, robust, and preferred for "Clean Core" environments.¹⁹
  • GUI-Based Agents: For legacy ECC systems where APIs are missing, SAP GUI Advanced MCP Servers allow agents to drive the SAP GUI directly (scripting). This enables agents to perform "swivel chair" tasks on legacy screens, bridging the gap until migration is complete.²⁰

7. Operationalizing the Agentic Enterprise: Use Cases

The synthesis of rigid structure and autonomous intelligence transforms key business functions.

7.1 Order-to-Cash (O2C): The Self-Driving Supply Chain

In O2C, agents reduce processing time by up to 70%.²¹

• Validation: Agents validate orders against contracts automatically.
• Stock Allocation: Instead of failing on a stock-out, an Inventory Agent performs a global Available-to-Promise (ATP) check across all plants, identifying potential transfers or substitutions, and proposing the optimal fulfillment path based on margin analysis.²²
• Logistics: A Logistics Agent interacts with 3PL portals via MCP to schedule pickups, updating the SAP Delivery document with the tracking number and carrier details.

7.2 Finance: Dispute Resolution and Cash Collection

The Cash Collection Agent.¹¹ proactively analyzes unpaid invoices.

• It detects a partial payment.
• It uses RAG to read the customer's email explanation ("Damaged goods").
• It correlates this with a Quality Notification in the system.
• Outcome: It autonomously proposes a credit memo for the damaged amount and clears the remaining balance, routing the proposal to a Finance Manager for one-click approval.

7.3 ESG and Sustainability: The Compliance Auditor Agent

Sustainability reporting (e.g., CSRD) is data-intensive and rigid.²³ Sustainability Agents ²⁴ act as auditors.

• They crawl the supply chain data in SAP.
• They chase suppliers for Scope 3 emissions certificates via email.
• They validate the certificates against the Sustainability Control Tower.²⁵
• The "hard" validation ensures that the reported carbon numbers are traceable and auditable, preventing "greenwashing" liability.

7.4 Post-Merger Integration (M&A)

M&A integrations are notoriously difficult due to mismatched ERPs. PMI Agents ²⁶ accelerate this.

• They "crawl" the legacy ERP and the target ERP.
• They identify semantic mappings (e.g., "Legacy Material Group 01 = SAP Material Group Z05").
• They automate the data migration and reconciliation, flagging anomalies for human review.

8. The Clean Core Imperative: Agents as Architects

The "Clean Core" strategy—keeping the ERP baseline free of custom modifications—is essential for Agentic AI.²⁷ Custom "Z-code" is often opaque to standard agents.

However, agents are also the solution to this problem. ABAP AI Agents can assist in the migration.²⁸

• Code Analysis: Agents scan millions of lines of legacy code.
• Refactoring: They identify non-compliant code (e.g., direct database updates) and rewrite it to use standard APIs or RAP (RESTful ABAP Programming) models.
• Documentation: They automatically generate documentation for undocumented legacy customizations.

Thus, the Agentic workforce helps build the "Clean Core" environment it requires to thrive.

9. Governance and the Future Workforce

The deployment of autonomous agents requires a new layer of governance.

9.1 Agent Mining

Just as Process Mining (e.g., SAP Signavio) is used to analyze human process adherence, Agent Mining ²⁹ is used to monitor digital workers.

• Performance: Are agents getting stuck in loops?
• Compliance: Are agents attempting to access unauthorized data?
• Optimization: Agent Mining visualizes the "digital exhaust" of the agent interactions, allowing architects to fine-tune the prompts and tools.

9.2 The Shift to Supervision

The role of the human worker shifts from "Operator" to "Supervisor." The frustration of navigating "hard" SAP screens disappears, replaced by the natural language interface of Joule. The "hardness" remains, but it is pushed "under the hood," acting as the safety constraints for the agents. The human focuses on defining the goals and managing the exceptions escalated by the agents.

Conclusion: The Fortified Citadel

The reputation of SAP ERP systems as rigid, complex, and unforgiving is well-earned. For a human user, these traits are bugs. For an AI agent, they are features.

• The Granularity of RBAC provides the Security Containment needed for autonomous software.
• The Friction of exception handling provides the Orchestration Signals for agent collaboration.
• The Strict Validation provides the Hallucination Guardrails against generative error.
• The Structured Data provides the Grounding for deep reasoning.

Organizations that embrace this paradox—viewing the "Iron Cage" of SAP not as a prison for humans, but as a cradle for AI—will achieve levels of automation and agility that are impossible in less rigorous environments. They are building not "floating castles," but fortified, autonomous citadels of intelligence. The "hard to run" ERP is, in fact, the only ERP safe enough for the AI era.

End of Report.

Note: The insights presented are synthesized from the provided research materials, integrating technical specifications of SAP BTP, Joule, and industry analysis on Agentic AI trends.

References

1. Agentic AI in SAP Ecosystems - Smarter Enterprise Solutions, accessed January 19, 2026, https://adspyder.io/blog/agentic-ai-in-sap-ecosystems/ ↩

2. The Rise of Agentic AI ERP - Rimini Street, accessed January 19, 2026, https://www.riministreet.com/resources/whitepaper/the-rise-of-agentic-ai-erp/ ↩

3. How agentic AI is transforming IT: A CIO's guide - SAP, accessed January 19, 2026, https://www.sap.com/resources/how-agentic-ai-transforms-it-cio-guide ↩

4. Does AI Confabulate or Hallucinate? - testRigor AI-Based Automated Testing Tool, accessed January 19, 2026, https://testrigor.com/blog/does-ai-confabulate-or-hallucinate/ ↩

5. AI agents: Thinking fast, thinking slow - SAP, accessed January 19, 2026, https://www.sap.com/blogs/balancing-autonomy-determinism-when-applying-agentic-ai ↩

6. AI Agent RBAC: Essential Security Framework for Enterprise AI ..., accessed January 19, 2026, https://medium.com/@christopher_79834/ai-agent-rbac-essential-security-framework-for-enterprise-ai-deployment-d9d1d4711183 ↩ ↩2

7. Authorization in the Age of AI Agents: Beyond All-or-Nothing Access Control, accessed January 19, 2026, https://nwosunneoma.medium.com/authorization-in-the-age-of-ai-agents-beyond-all-or-nothing-access-control-747d58adb8c1 ↩

8. Setup Principal Propagation for SAP BTP - Simplifier Community, accessed January 19, 2026, https://community.simplifier.io/doc/installation-instructions/setup-external-identity-provider/setup-principal-propagation-for-sap-btp/ ↩

9. PFCG BASED AGENT RULE SET UP Step by Step 1694177786 | PDF - Scribd, accessed January 19, 2026, https://www.scribd.com/document/863648565/PFCG-BASED-AGENT-RULE-SET-UP-step-by-step-1694177786 ↩

10. Best Practices and 5 Use Cases of SAP BTP Integration Suite - LeverX, accessed January 19, 2026, https://leverx.com/newsroom/sap-btp-integration-suite-use-cases ↩

11. How SAP Uniquely Delivers AI Agents with Joule, accessed January 19, 2026, [https://news.sap.com/2025/02/joule-sap-uniquely-delivers-ai-agents/](https://news.sap.com/2025/02/joule-sap-uniquely-delivers-ai-agents/](https://news.sap.com/2025/02/joule-sap-uniquely-delivers-ai-agents/) ↩ ↩2 ↩3

12. AI Agents Use Cases in the Enterprise | SAP, accessed January 19, 2026, https://www.sap.com/hk/resources/ai-agents-use-cases ↩

13. How Agentic AI is Transforming Enterprise Platforms | BCG, accessed January 19, 2026, https://www.bcg.com/publications/2025/how-agentic-ai-is-transforming-enterprise-platforms ↩

14. What Is a Knowledge Graph? - SAP, accessed January 19, 2026, https://www.sap.com/resources/knowledge-graph ↩

15. Retrieval Augmented Generation (RAG) - SAP Architecture Center, accessed January 19, 2026, https://architecture.learning.sap.com/docs/ref-arch/e5eb3b9b1d/3 ↩

16. Joule, the AI Copilot for SAP - SAP Community, accessed January 19, 2026, https://pages.community.sap.com/topics/joule ↩

17. Joule Studio Agent Builder Hits General Availability, Signaling Shift in Agentic AI, accessed January 19, 2026, https://sapinsider.org/blogs/joule-studio-agent-builder-hits-general-availability-signaling-shift-in-agentic-ai/ ↩

18. Agent builder in Joule Studio is now generally ava... - SAP Community, accessed January 19, 2026, https://community.sap.com/t5/artificial-intelligence-blogs-posts/agent-builder-in-joule-studio-is-now-generally-available-build-your-own/ba-p/14289282 ↩

19. API Agents vs. GUI Agents: Divergence and Convergence - arXiv, accessed January 19, 2026, https://arxiv.org/html/2503.11069v1 ↩

20. SAP GUI AI Agent: Architecture and Technical Details, accessed January 19, 2026, https://community.sap.com/t5/artificial-intelligence-blogs-posts/sap-gui-ai-agent-architecture-amp-technical-details/ba-p/14032043 ↩

21. Introducing Generative and Agentic AI into the O2C Process - SSON, accessed January 19, 2026, https://www.ssonetwork.com/finance-accounting/articles/generative-agentic-ai-order-to-cash ↩

22. Order to Cash Automation with AI Agents | Beam AI, accessed January 19, 2026, https://beam.ai/use-cases/order-to-cash ↩

23. AI-Driven ESG Reporting: How Agentic AI Can Cut Disclosure Prep from Weeks to Hours, accessed January 19, 2026, https://www.superteams.ai/blog/ai-driven-esg-reporting-how-agentic-ai-can-cut-disclosure-prep-from-weeks-to-hours ↩

24. AI Agents in Sustainability Reporting: Powerful Wins | Digiqt Blog, accessed January 19, 2026, https://digiqt.com/blog/ai-agents-in-sustainability-reporting/ ↩

25. SAP Sustainability Control Tower, accessed January 19, 2026, https://www.sap.com/products/scm/sustainability-control-tower.html ↩

26. Pharma IT Integration Playbook: Consolidating Veeva and SAP | IntuitionLabs, accessed January 19, 2026, https://intuitionlabs.ai/articles/pharma-it-integration-veeva-sap ↩

27. SAP Clean Core Strategy For SAP Cloud ERP And Technical Debt ..., accessed January 19, 2026, https://www.redwood.com/article/sap-clean-core-strategy-cloud-erp/ ↩

28. SAP BTP‚ ABAP environment, Joule for developers‚ ABAP AI capabilities, accessed January 19, 2026, https://www.sap.com/products/technology-platform/btp-abap-environment-joule-for-developers-abap-ai-capabilities.html ↩

29. Unleashing the full potential of AI agents with SAP Signavio- SAP ..., accessed January 19, 2026, https://www.signavio.com/post/unleashing-the-full-potential-of-ai-agents-with-sap-signavio/ ↩