Explaining the Process Layer Transformation

Imagine a complex business process like hiring a third-party developer. Traditionally, this would involve navigating multiple applications across procurement, legal, finance, and IT, each with its own systems and approval chains. This rigid, predefined approach often leads to bottlenecks and inefficiencies.

Now, picture a future where intelligent agents can seamlessly orchestrate this entire process, discovering and invoking capabilities across disparate systems, adapting to real-time changes, and escalating to human intervention only for critical decisions. This is the vision of the transformed process layer in enterprise AI.

This lesson explains how the process layer shifts from rigid, predefined paths to agent-enabled orchestration that spans multiple systems.

For decades, enterprise business processes have been defined by rigid, predefined paths, with logic embedded directly within individual applications. While functional, this approach often confines automation and intelligence within application boundaries, leading to fragmented workflows and limited adaptability. The advent of AI-native architectures fundamentally transforms this, moving towards a process layer where applications become flexible capability providers for intelligent agents that can orchestrate complex tasks across an entire enterprise landscape.

This transformation redefines how process logic is structured and executed. In traditional AI-first models, AI assists process execution, automating steps or suggesting actions, but always within the confines of a single application. In the AI-native model, applications evolve into capability providers, exposing stable APIs, events, and data that agents can discover and invoke. This allows intelligent agents to sit on top of applications, orchestrating outcomes across the enterprise rather than being limited by individual product boundaries. This decoupling of agents from application release cycles means innovation can accelerate without being tied to lengthy upgrade timelines.

The process layer is architected into three distinct sub-layers, each playing a crucial role in bridging deterministic logic with adaptive intelligence:

The App Dev and Workflow Layer

The deterministic backbone where traditional applications and structured workflows are built.

The Bridge Layer

The connector between deterministic systems and agentic systems.

The Agentic Layer

The layer extending the system with adaptive intelligence.

This layer represents the foundational, deterministic core of the process layer. It is where traditional applications and structured workflows are built and executed. It leverages established development approaches like the AI Golden Path, which provides comprehensive guidance, from foundation services through agent development to production deployment.

However, real business scenarios rarely involve building and deploying a single agent. A procurement solution, for example, combines an application for purchase requisitions, an approval workflow for spend authorization, and one or more agents for supplier selection and contract compliance. These components are managed as a single deployable solution with a shared lifecycle and dependencies.

This layer ensures that the reliable, compliant, and governed aspects of business processes remain robust, forming the essential foundation upon which more adaptive, agentic capabilities can be built.

SAP supports building solutions across the determinism-autonomy spectrum: deterministic apps and workflows for predictable control flow, bounded agents with defined toolsets and guardrails, and open-ended agents for complex reasoning with broader autonomy.

There are two creation paths:

• A pro-code path where developers write agent logic directly with a standardized agent software development kit for full flexibility.
• A prompt-driven path that translates natural language intent into a code-based agent through assisted authoring via the Joule Studio solution.

Joule Studio is the unified design-time environment that supports both paths to produce code as the canonical representation: portable, version controlled, and auditable through standard developer tools. Customers can start with low code and graduate to pro code without rearchitecting. Paths deploy to a unified runtime and follow an AI Golden Path.

For production solutions, the flow progresses from business intent through a product requirements document, specification, and code generation to deployment. This process is informed by:

• Process knowledge from SAP Signavio.
• Landscape data from SAP LeanIX.
• Domain models from SAP Knowledge Graph.

The same approach extends to transformation and migration. In the AI-first model, moving from legacy to cloud is human led and labor intensive. In the AI-native model, agents accelerate code migration, data transformation, and test automation, reducing modernization time, risk, and downtime.

Trust and governance for agent interactions—including agent identity, open protocol standards, and governed integration—are essential components of this layer. Ultimately, the process layer transformation enables a dynamic, intelligent enterprise where processes are orchestrated by agents that learn and adapt, moving beyond rigid workflows to outcome-driven execution across the entire business landscape.

• Shift to Agent-Enabled Orchestration: The process layer is evolving from rigid, application-embedded logic to dynamic, agent-enabled orchestration that spans multiple systems.
• Applications as Capability Providers: In the AI-native model, applications expose APIs, events, and data, allowing intelligent agents to discover and invoke their capabilities.
• Three Sub-Layers: The process layer is structured into the App Dev and Workflow Layer (deterministic backbone), the Bridge Layer (connecting deterministic to agentic systems), and the Agentic Layer (adaptive intelligence).
• Agent Gateway and Protocols: The Agent Gateway is the mandatory hub for agent interactions, utilizing the Model Context Protocol (MCP) for tool invocation and the Agent2Agent (A2A) protocol for multi-agent coordination.
• Flexible Agent Development: Agents can be built via pro-code (SDKs) or prompt-driven (Joule Studio) paths, with code as the canonical representation.