Abstractions for the Agentic Enterprise

wso2 platformengineering ai/agenticai conference

Abstractions for the Agentic Enterprise

Speaker: Asanka Abeysinghe (Chief Technology Officer, WSO2)
Conference: WSO2Con North America 2026

[!video]- Abstractions for the Agentic Enterprise

Tldr

• The Core Paradigm Shift: Every architectural era is defined not by what it adds, but by what it hides. The agentic era abstracts away manual workflow execution, moving the human role up the stack to pure Intent.

• The Three-Legged Model: Designing a well-abstracted enterprise requires balancing Intent (defining goals, not tasks), Context (dynamic real-time data access), and Boundaries (design-time constraints and cells).

• Leaky Abstractions: Traditional enterprise systems (including human-centric APIs and manual approvals) act as bottlenecks and break the non-deterministic reasoning loops of AI agents.

• Architecture Evolution: Modern enterprises must transition from classical API-and-Service integration to a layered topology incorporating Agent Gateways, MCP (Model Context Protocol) Gateways, and Context Graphs.

• Focus on Outcomes: Technology platforms are only structural facilitators; the final metric of success is the value and music (business outcome) delivered to the end-user.

1. Introduction & Tributes

Before diving into technical architecture, the presentation honors WSO2’s late founder, Sanjiva Weerawarana, highlighting his legacy as an architect, first-principles thinker, and deeply empathetic leader.

Key Quotes

• Sanjiva Weerawarana: “Stop adding noise, send signals worth hearing.”

• Kobe Bryant: “Heroes come and go, but legends are forever.”

This first-principles approach taught by Sanjiva forms the architectural foundation for analyzing how we design systems in the AI and agentic era.

2. The Abstraction Journey (The Guitar Analogy)

To understand abstractions, consider the process of learning to play a guitar.

The Guitar Learning Analogy

• Stage 1 (Fingers): Beginners focus entirely on mechanical execution—where to place fingers, how to press strings. This represents low-level, manual execution.

• Stage 2 (Chords): Once muscle memory is established, focus shifts up to structural groupings—playing chords.

• Stage 3 (Music/Outcome): For professional musicians, fingers and chords are entirely abstracted. They only focus on the music itself and how the audience reacts.

Abstractions hide the underlying complexities (fingers/chords) so that developers and architects can focus on the ultimate value (the music).

Historically, software engineering has followed this exact sequence of hiding complexity to raise the level of developer focus:

graph TD
    A[Client-Server Era] -->|Abstracted/Hid: The Machine/Hardware| B[Web Era]
    B -->|Abstracted/Hid: Location| C[Cloud Era]
    C -->|Abstracted/Hid: Infrastructure| D[Agentic Era]
    D -->|Abstracts/Hides: Execution & Workflows| E[Pure Business Intent]
    
    style E fill:#f9f,stroke:#333,stroke-width:2px

3. The Enterprise execution Bottleneck

Most modern enterprises are designed and structurally optimized for manual execution.

Traditional Manual Workflows

These systems rely on rigid, step-by-step processes driven by human intervention:

graph LR
    A[Identify] --> B[Interpret] --> C[Approve] --> D[Trigger]

• High latency due to waiting for manual reviews and sign-offs.
• Filled with accumulated technical debt and legacy operational structures.

The Agentic Approach

3. Agentic AI and Autonomous Systems > The ReAct Framework (Reason + Act)

AI Agents operate in non-deterministic, autonomous loops. They do not follow hardcoded decision trees; instead, they navigate environment states dynamically:

graph LR
    A[Plan] --> B[Reason] --> C[Act]
    C --> A

Leaky Abstractions

When agents are forced to interact with legacy interfaces built for humans, the abstraction “leaks.” For instance, standard REST APIs are heavily optimized for human developers reading documentation. Forcing agents through these traditional interfaces creates friction, safety concerns, and failure states.

4. The 3-Legged Model for the Agentic Enterprise

To design an enterprise that agents can safely navigate and humans can easily govern, architects must establish a Three-Legged Abstraction Model:

Leg 1: Intent (Abstracting the Goal)

Instead of detailing how to do a task, define what needs to be achieved. In the guitar analogy, this is abstracting the song (the outcome), not the finger movements.

• Define Goals, Not Tasks: Avoid scripting specific workflows (which reverts systems back to deterministic, brittle structures).
• Encode Constraints Upfront: Since agents act autonomously, guardrails and limits must be declared and fed to the agent before execution begins.
• Define Success Metrics: Define explicit parameters for evaluating whether the agent has achieved the desired state.

Leg 2: Context (The Sheet Music)

Context is not merely a raw dump of data. It represents the structural information an agent needs to reason accurately.

• The Analogy: Sheet music/notes that give structure and direction to a musician’s play.
• Keep it Current: Context must reflect real-time, dynamic system state.
• Make it Accessible: Provide interfaces through standardized tooling, secure APIs, and protocols like the Model Context Protocol (MCP).
• Protect Context: Shield sensitive data by applying strong domain boundaries (e.g., Domain-Driven Design) to restrict what context each agent can access.

Leg 3: Boundaries (The Fretboard)

Boundaries define the physical/runtime limits within which execution can happen.

• The Analogy: The guitar fretboard, which physically constrains and guides where notes can be played.
• Enforced by Design: Boundaries must be declared at design time and codified in machine-readable policies rather than applied post-facto at runtime.
• Decentralized Execution with Federated Control: * Data Plane: Decentralized execution environments where individual workloads and agents operate autonomously.
  • Control Plane: Centralized, federated oversight that establishes uniform security policies, identity tokens, and governance rules.

5. Architectural Implementation: Cells and Domains

To implement these boundaries effectively, WSO2 advocates combining Domain Driven Design with Cell-Based Architecture (CBA).

The Fish Tank Analogy

• The Cell acts as a fish tank (a rigid, secure boundary).

• The Components are like fish inside the tank. They can interact freely inside but must pass through structured, secure gateways to communicate with external systems.

graph TD
    subgraph Cell Boundary [Cell / Bounded Context]
        ComponentA[Component/Agent A] <--> ComponentB[Component/Agent B]
    end
    Gateway[Cell Gateway] <--> CellBoundary
    Gateway <--> External[External Services]

• DDD defines the logical Bounded Context.
• Cell-Based Architecture provides the physical Runtime Environment.
• Rule of Thumb: If a human must manually step between boundaries to copy data or pass approvals, they become a system bottleneck, breaking the autonomous execution loop.

6. The Shift in Human Roles

When this three-legged model is correctly applied, the structure of the enterprise shifts, moving human workers and engineers up the complexity stack:

Operational Component	Before Agentic Era	In the Agentic Era
Humans (Developers & Operators)	Manual Execution, Coding Steps, Writing Workflows	Defining Intent, Designing System Guardrails
Agents	N/A (or basic scripted automation)	Autonomous Execution, Planning, and Reasoning
Architecture (System & Platform)	Static plumbing, Routing, Data Hosting	Carrying Context and Enforcing Boundaries

7. The Agentic Enterprise Reference Architecture

Transitioning to an agentic enterprise requires evolving classical integration architecture. Rather than building parallel, siloed AI systems, architects must seamlessly integrate AI components into core enterprise systems.

Traditional Enterprise Architecture (Classic)

• Clients run queries against API Gateways.
• Gateways route to Services and Integration Layers.
• Identity providers handle user access.
• Services fetch from static Systems of Record.

Agentic Enterprise Architecture (Evolved)

The target architecture introduces crucial structural additions (highlighted below):

• Agent Gateway: Inspects, filters, and monitors LLM/Agent traffic (applies prompt guardrails, PII masking, rate-limiting, and cost control).
• MCP Gateway: Dynamically exposes secure, structured tools and contextual endpoints to agents.
• Knowledge Bases & Context Graphs: Transform static databases into queryable semantic data sources.

8. Summary: Keep Your Eye on the Music

At the end of the day, platforms, agents, LLMs, and integration fabrics are only mechanics. The true measure of any enterprise modernization is business value.

Focus on the Music

Platforms and agents are the instruments. The business value, customer experiences, and operational outcomes are the music. Architects must focus on generating beautiful music, keeping technical debt low and abstractions clean.

For a deep dive into implementation patterns, read the official WSO2 whitepaper on Abstractions for the Agentic Enterprise.