Agenda

Java has been a trusted foundation for our products, but as the software landscape evolved with the rise of microservices and SaaS, we felt the need to explore better options. Performance, resource consumption, and language capabilities became key considerations, leading us to evaluate newer programming languages, each with its own strengths.

In this discussion, we want to hear from you! What challenges have you faced in your application development journey? How have language choices impacted your architecture and scaling efforts? We'll also share our experiences and the initiatives we've taken in adopting Go and other languages to enhance our technology stack.

Join us for an open, interactive conversation about the changes we are making in our technology stack and share your experiences as well.

APIs were designed for deterministic applications, where developers define the sequence of calls, handle errors, and control retries. AI agents change these assumptions. They discover capabilities dynamically, make probabilistic decisions, explore multiple paths, retry operations, and invoke APIs at machine speed. An API that works well for a conventional application may therefore be ambiguous, inefficient, or even unsafe when consumed by an agent.

This talk explores what it means to design APIs and MCP servers for AI readiness. We will examine how APIs can better communicate intent through task-oriented operations, machine-readable errors, explicit side-effect and retry semantics, idempotency, dry-run support, bulk operations, and cost or rate hints. We will also look at how machine-readable capability descriptions and workflow specifications can help agents discover not merely individual endpoints, but the business outcomes they can achieve.

MCP provides an agent-friendly layer over existing systems, but simply converting every API endpoint into an MCP tool is an anti-pattern. It exposes implementation details, increases tool-selection complexity, and forces agents to reconstruct business workflows at runtime. Using practical examples, we will explore how to choose the right tool granularity, design intent-oriented tools, compose API operations into meaningful capabilities, and keep business logic in the appropriate layer.

Platform engineering emerged to shield developers from the complexity of cloud-native infrastructure, with Internal Developer Platforms (IDPs) providing self-service, golden paths, automation, and governance.

Now, AI agents are becoming active participants in the software lifecycle—building, deploying, troubleshooting, and operating software alongside humans. At the same time, agents themselves are becoming workloads that platforms need to manage, secure, observe, and govern.

This session explores how IDPs are evolving for this new reality: from platforms designed primarily for developers to AI-native platforms where humans and AI agents operate through the same abstractions, context, workflows, and guardrails. We’ll explore the key capabilities required for this evolution and use OpenChoreo as a practical example of what an IDP for humans and AI agents can look like.

Most organizations don't lack AI tools, they have too many of them, and having more tools hasn't translated into more productivity. At WSO2, we moved from a fragmented set of AI tools to a single platform used across every function. This talk covers why we made that call and the problems it solved. Rolling it out meant more than a technology decision: we had to close skills gaps, address genuine concerns about what this meant for people's roles, and build a network of champions across teams to drive adoption from within rather than mandate it top-down. We'll share what that consolidation delivered, the governance gains it brought, what it cost, and how we keep that cost under control as adoption grows.

The gap between enterprise AI leaders and laggards is widening, and traditional governance is often the anchor holding teams back. As we move from generative pilots into the era of the agentic enterprise, where autonomous AI agents are digital coworkers and users within  - and of - your systems, the rules of adoption fundamentally change.

In this keynote, we’ll cut through the latest AI trends to explore the enterprise fabric required for this new reality. Drawing on examples from WSO2’s landscape, we’ll discuss how to design for an architecture that supports autonomous systems, and how embedding trusted AI governance directly into that fabric turns it from a restrictive bottleneck into a powerful enabler for secure, rapid innovation.

Becoming an agentic enterprise is not a maturity exercise. It is a sequence of capabilities that must be established in the right order, based on enterprise strategy, from safe AI access and grounded enterprise knowledge to process automation, delegated authority with autonomous agents, and new business models. This keynote shows how that path can drive two outcomes: greater efficiency and lower risk inside the enterprise, and new growth through exposed capabilities, autonomous operations, and new revenue streams. It also explains what must be true before each next step is safe, governable, and able to deliver measurable value and outcomes.

The rise of AI agents is reshaping the enterprise architecture landscape. As agents move beyond experimentation and begin participating in real business processes, their effectiveness depends on their ability to securely access enterprise data, invoke business capabilities, respond to events, and coordinate work across an increasingly distributed technology landscape.

This makes integration a foundational capability for the agentic enterprise. But the integration challenge is also changing. Enterprises are no longer connecting only applications, APIs, and data. They must now connect a new ecosystem of agents, models, tools, knowledge, events, people, and existing business processes, while bridging deterministic enterprise systems with the non-deterministic nature of AI.

In this session, we’ll explore the architecture of the connected agentic enterprise and the evolving role of integration within it. We’ll examine how existing enterprise capabilities can become accessible to agents, how context and actions flow across the enterprise, and why established integration principles remain critical even as new agentic patterns emerge.

We’ll also look at how the integration platform itself must evolve to support this new landscape, establishing the foundation for AI-native integration development and for operating agents and integrations with the security, governance, and control required by the enterprise.

Traditional enterprise integration was built for a predictable world—connecting applications, APIs, and data through static, rule-based workflows. However, the rise of the agentic enterprise demands a fundamental shift: systems where autonomous agents, large language models, and enterprise capabilities adapt and interact in real time.

AI-native integration isn't about simply bolting AI features onto existing middleware. It represents a complete reimagining of architecture, moving intelligence from an external add-on directly into the integration fabric. In this session, we will explore what AI-native integration looks like in practice, shifting from deterministic orchestration to context-aware execution.

Key takeaways:

• From Static to Adaptive: How integration patterns evolve when replacing fixed workflows with dynamic agentic execution.
• Agent-Ready APIs: Designing and exposing secure enterprise capabilities and data streams optimized for both human and AI consumers.
• Governance & Observability: Strategies for managing security, compliance, and real-time monitoring across non-deterministic, AI-driven integration flows.
• Practical Architectural Patterns: What remains foundational in integration engineering versus what must be rebuilt for the AI era.

Enterprises have spent years getting integration right. APIs, events, automations and workflows, each with clear ownership, access control and monitoring around it. AI agents are now showing up in the same space, but they don't behave the same way. An integration does what you designed it to do. An agent decides for itself what to call and when, and that changes what governance has to look like.

The talk takes the view that an agent is not a separate world. It is another consumer of the integration layer, sitting next to the APIs and events already running there. What makes it different is the handful of controls that have to be added around it: an identity of its own, boundaries on the tools it can reach, a limit on what it spends, and a record clear enough to explain a decision after it happened.

Enterprises have spent a decade building identity for people. But while most are still finishing, AI agents are already arriving in volume. When you introduce an actor that behaves non-deterministically, operates continuously, acts on someone else's behalf, and reaches into every system you own, unfinished identity work stops being architectural debt and becomes acute operational risk. Finishing the baseline is no longer enough. The identity fabric itself must evolve.

This session takes the platform-level view of that evolution, now that the actor may or may not be human. We cover treating agent identities as first-class citizens; continuous identity assurance, where verification, fraud detection and analytics converge inside CIAM because a login alone proves little about who or what is on the other end; and unified, consented customer data that reaches beyond identity, so those journeys are decided on knowledge of the customer rather than on inference.

We then look at the future of the WSO2 identity fabric: a new identity runtime that prepares the platform for the next decade of IAM, readiness for portable verifiable credentials that may not have been issued by you, crypto agility for the post-quantum transition, and the governance and privileged-access disciplines that machine and agent populations will demand.

The agentic enterprise runs on a decision most organisations have not consciously made: how much authority to hand software that acts on its own.

That authority rests on two questions, and most organisations have answered neither.

First, who is the agent? Before you grant anything, you need to know this is the agent it claims to be, who built it, who owns it, and that it has not been tampered with or replaced. An agent presenting a shared key proves nothing about any of that.

Second, whose authority does it carry? Sometimes a customer's, sometimes an employee's, sometimes a partner acting for their own client. And sometimes none of the above, because the agent was triggered by a schedule with no human anywhere in the loop. That last case is the one most organisations are least prepared for, and the one growing fastest.

This session is a practical guide to getting agent identity right, with no prior background assumed. Attendees will leave a framework to design agentic use cases into a digital journey from the start, and to put the identity foundations in place before granting autonomy.

Healthcare is digitizing fast, but the next wave of digital health won't be built on portals and dashboards alone. AI agents that can understand a situation, make decisions, and take action across health records, insurance platforms, supply chains, and care programs give the healthcare enterprise a new operating system: one where software doesn't just show information, but takes on real work.

This session presents a practical architecture for making that shift safely. We'll look at what it takes to trust agents in a field where mistakes carry real consequences: how agents are identified and given permissions, where humans stay in the loop, how their actions are monitored, and how existing standards like FHIR let agents work with the systems already in place. We'll also cover where to start, how to manage risk while scaling, and why health systems with less legacy infrastructure can adopt this model faster.

Attendees will leave with a clear blueprint and a realistic roadmap for evolving into an agentic healthcare enterprise.

The number of parties acting inside a bank keeps growing. Customers and staff, then partners and fintechs, then corporates delegating authority to one another and distribution embedded in someone else's product. Now AI agents, both the ones the bank deploys itself and the ones customers will arrive holding.

What has not grown is the way banks control any of it. Most institutions still decide who may do what separately in every channel and every vendor platform, with the rules buried in application code and the evidence scattered across systems they will replace within a decade. That is barely manageable at today's scale. It does not survive the next, and it does not survive an actor operating at machine speed with no human in the session.

All of it turns on the same two questions. When an action happens inside the bank, who authorised it and acting for whom. And what data and capability was that actor entitled to reach, on what terms, with what record left behind. Answer those once, in one governed layer the institution owns outright, and every new party becomes a configuration problem rather than another integration project.

This session walks through what that layer needs. Identity and consent, delegated authority and entitlement enforcement, the data and capability plane that exposes core and third-party systems as governed API products rather than point-to-point access, and the lifecycle controls that make an AI agent an accountable enterprise asset with an owner, a mandate, and an audit trail. It maps each to what WSO2 ships as the Agentic Enterprise Fabric, and shows them working across what banks are building now: partner and developer platforms, open banking, embedded finance, corporate connectivity, payment enablement, and AI agents as governed bank actors.

Every government faces the same three questions at once: who are our citizens digitally, how do agencies share data, and where does AI actually run? Answered separately, they produce a decade of disconnected projects. Answered together, they produce a sovereign government operating system - three layers a nation can own, host and audit.

Drawing on WSO2's work behind 18 national ID deployments and 2.5 billion identities across 42 governments, this session walks through those layers: sovereign digital identity for citizens, workforce and organisations; a national data exchange built on the open source OpenNDX stack; and the citizen services that sit on top. We'll show where AI agents genuinely add value - and how to adopt them without handing over control of your data or your models.

Vinod Sharma draws on 25 years of building mission-critical financial infrastructure (M-Pesa Africa, Ascend Money/TrueMoney, Econet & EcoCash, Saolix) to argue that in fintech, downtime isn't an inconvenience — it's someone's livelihood. He walks through how mobile money platforms scaled to 100M+ users and $1B+ in daily transaction value, the GMPI framework for balancing growth, maintenance, protection, and transformation on one budget, and why architectural debt should be treated as a tax, not ignored.

The core of the talk is the "Determinism Boundary": AI systems (LLMs, RAG, agents) can explore, retrieve, and act, but only deterministic rules are allowed to actually decide on money movement—authorization, ledgers, settlement. Using a real production failure as a case study, plus frameworks like Know Your Agent (identity/scope/audit for autonomous systems) and Landauer's Principle applied to AI, Sharma makes the case that autonomy in finance has real physical and regulatory limits, and must be engineered with that in mind.

In this live podcast-style session, WSO2’s CTO will be joined by customer executives and industry influencers for a candid discussion on what it really takes to lead in the agentic era. The conversation will explore how enterprises are thinking about AI agents, modernization, governance, and the operating changes needed to turn early momentum into lasting business value. Expect a practical discussion grounded in real-world leadership perspectives, not theory.

AI agents are only as successful as the enterprise systems they have access to, but the existing systems they have in place were not built for agentic consumption. Integration is what bridges the gap, allowing AI agents to access existing systems without a complete rebuild, making integration a key enabler of the agentic enterprise. The right integration technology therefore, enables enterprises to become agentic while continuing to leverage their existing technology investments.

Our panel of experts will cover how they are using integration to enable their own agentic enterprise, and also share best practices and learnings from their experiences.

As financial institutions expand their use of APIs, identity and access management becomes essential to protecting critical payment services and maintaining operational resilience. This session presents lessons from the Bank of Tanzania’s WSO2 journey, focusing on securing API access, strengthening identity governance, and supporting reliable payment-system operations. It will discuss practical considerations in authentication, authorization, platform governance, system integration, and resilience within a central-bank environment. Attendees will gain applicable insights into balancing security, regulatory responsibilities, operational continuity, and modernization when implementing identity and API-management capabilities.

As AI agents become active participants in software development and operations, Internal Developer Platforms must evolve beyond serving human developers alone. This panel explores how IDPs can provide a common foundation for humans and AI agents to build, deploy, manage, and operate software, with shared abstractions, context, governance, and guardrails. Hear different perspectives on what this shift means for platform engineering and the enterprise.

While African enterprises are modernizing legacy environments to prepare for AI-driven services, APIs have become far more than technical interfaces. They are the foundations through which organizations expose capabilities, connect ecosystems, enforce trust and enable intelligent action.

Drawing on her bank’s journey with WSO2 Enterprise Service Bus and API Manager, Janey Rachel Nakato shares how an initial integration requirement evolved into a strategic API platform scaled to support a 10-fold growth transactions volume and enabled services such as QR payments, digital savings, government collections and ecosystem partnerships.

The keynote explores why effective API management extends beyond gateways and traffic control to include API product ownership, lifecycle governance, security, discoverability, observability, reuse and measurable business value. It also examines how these disciplines must evolve as APIs increasingly become tools consumed dynamically by AI agents.

Executives in attendance will leave with practical lessons on scaling API platforms, establishing shared ownership, developing internal capability and preparing their organizations to govern both human and non-human consumers. The central message is that organizations that govern their APIs effectively today will be better positioned to trust and scale intelligent systems tomorrow.

Enterprise integration is defined not by the technology it uses, but by how quickly it enables the business to respond to change.

This session explores how Alexforbes built a cloud-native integration platform using WSO2 API Manager and Micro Integrator on Kubernetes to support a highly regulated financial services environment. The platform ensures data sovereignty while delivering the scalability, resilience and operational benefits of a cloud-native architecture, with the flexibility to run selected services in the cloud or on-prem as required.

Through two real-world case studies—the introduction of South Africa's Two-Pot Retirement System and the rapid enablement of an enterprise AI platform—we demonstrate how the platform enabled governed and resilient delivery within weeks. We also share practical lessons from operating a platform processing five million API requests daily, covering observability, automation, rate limiting, governance and rapid Kubernetes patching for operational resilience.

Internal developer platforms were designed around a human bottleneck. Golden paths, service catalogs, and self-service portals all exist to compress what a developer must know before they can ship.

AI agents invert every one of those assumptions. They don't struggle to discover a service; they struggle to know what they're allowed to break.

In this session, Divine will look at what actually has to change in a platform when a significant share of deployment traffic stops being human.

He'll cover the shift from UI abstractions to declarative capability contracts; why policy-as-code and admission control become the real interface rather than a safety net; what reconciliation loops offer that request/response agent tooling does not; and where emerging surfaces like MCP fit against the Kubernetes resource model platform teams already run.

Drawn from what platform teams across the cloud-native ecosystem are building today.

AI is no longer just a coding assistant, it's becoming an integrated partner across the entire software development lifecycle. In this session, explore how AWS's AI-Driven Development Lifecycle (AI-DLC) is transforming how enterprises build software, with Kiro, AWS's spec-driven agentic IDE, at the center. See how Kiro turns requirements into production code through autonomous agents, and how AWS Transform completes the picture with AI-driven modernization. Walk away with a practical roadmap for making your development process AI-native.