1. Overview
Enterprise AI is no longer just about chatbots answering questions or copilots suggesting text. The next frontier is agentic AI — autonomous systems that reason, act, and complete multi-step processes end-to-end. Pega has been building toward this moment for years with its Centre-Out architecture. The question was never whether Pega could support agentic workflows; it was how external AI agents would connect to it.
The Agent-to-Agent (A2A) protocol answers that question. This article explores a working implementation where a Google ADK-based AI agent drives a Pega complaint case from initiation to resolution — dynamically collecting every field, navigating every screen, and closing the case without a human touching a Pega UI.
Key Insight: A2A is not a chatbot integration. It is a machine-to-machine protocol that lets any AI agent become a fully capable Pega front-end — one that can reason, converse, and act.
2. What is the A2A Protocol?
A2A (Agent-to-Agent) is an open protocol that defines how AI agents from different vendors communicate. It establishes a standard contract for agents to discover each other, exchange messages, and coordinate tasks — regardless of the underlying platform or model.
In the Pega context, A2A exposes the Pega workflow engine as an agent endpoint. An external agent — built on Google ADK, LangChain, or any A2A-compliant framework — can connect to Pega’s Agent and drive cases programmatically using natural language messages.
How It Works at a Protocol Level
-
Agent Card Discovery: The external agent fetches the Pega agent.json card — a machine-readable descriptor that advertises the Pega agent’s capabilities and interaction endpoint.
-
Message/Send: Every message is sent as a JSON-RPC message/send call over HTTPS, carrying the user’s input and a context ID that maintains session continuity across turns.
-
Dynamic Screen Handling: Pega’s Agent processes the message against the current assignment screen, collects the field value, advances the case, and returns the next prompt — all autonomously.
-
Authentication: OAuth2 client credentials secure every call — no session cookies, no UI tokens, no browser.
3. The Implementation — What Was Built
Building on the momentum from PegaWorld — where Labb demonstrated cutting-edge Voice AI integration using the CARA conversational agent —this implementation represents a powerful extension of the Agentic Issue Resolution (AIR) framework. By combining the real-time, multi-modal interaction capabilities of AIR with the A2A protocol, the ecosystem evolves from standard conversational interfaces into an elite multi-agent orchestration network.
While AIR establishes the foundational runtime for agentic execution for issue/complaint resolution, integrating the A2A protocol transforms Pega into a pure, headless engine of intelligence. It proves that whether an external agent is handling text via a web UI or streaming real-time spoken voice, the integration pattern remains identical: the external channel seamlessly adapts to Pega’s centralized Centre-Out logic. This milestone firmly positions the platform as the ultimate, predictable enterprise backend for the entire agentic AI era.
A Complaint Assistant was built using Google’s Agent Development Kit (ADK) as the external AI agent, integrated with a Pega platform instance running a complaint management application.
Architecture at a Glance
User → Google ADK Agent (ComplaintAssistant) → Pega A2A Endpoint → Pega Case Engine → Case Created & Resolved
Figure: ADK web UI showing a live A2A trace — every user turn triggers an answer_pega tool call, with pega_context_id maintaining session state across all 22 events.
The trace above is from a real session. A few things worth noting: event 4 shows open_pega_session() firing the moment the user expresses intent to raise an issue; events 8, #12**,** #16**, and** #20 each show answer_pega being called for every user reply with no gaps; and the State panel at #13, #9, #13, #17 confirms pega_context_id persisting across the entire session. The agent graph on the left visually confirms the two-tool architecture — complaint_assistant with open_pega_session and answer_pega as its only capabilities.
The ADK agent acts as a pure pass-through proxy — it has no knowledge of Pega’s data model, screens, or field structure. All case logic, field sequencing, and validation lives in Pega where it belongs. The agent’s only job is to route user input to Pega and relay Pega’s responses back to the user.
Key Design Decisions
-
Zero Logic in the Agent: The ADK agent carries no Pega business logic whatsoever.
-
Stateless Session Management: A context ID returned by Pega on first contact is threaded through every subsequent message, maintaining session state without server-side sessions in the agent.
-
Containerised Deployment: The agent is packaged as a Docker container. Anyone with Docker and valid credentials can run it in minutes — no Python environment, no dependency management.
-
Configuration-Driven: All environment-specific values (Pega URL, OAuth credentials, Gemini model) are externalised to a .env file. The image contains no secrets.
-
Dual Run Modes: Both adk web (browser UI) and python agent.py (terminal) are supported from the same codebase.
Case Landing in Pega
The screenshot below confirms the complaint raised via the A2A conversation landed as a fully formed Pega case (ISS-16001), progressed autonomously through multiple stages, and triggered downstream AI processing — all without a human touching the Pega UI.
4. Alignment with Pega’s Centre-Out Architecture
Centre-Out is Pega’s foundational architectural philosophy: build business logic once, at the centre, and let any channel — web, mobile, voice, API — consume it without duplicating that logic in the channel layer. The architecture enforces a clean separation between what the business does and how it is presented.
A2A is perhaps the purest expression of Centre-Out ever realised. Consider what this implementation demonstrates:
Centre-Out Principle
How A2A Delivers It
Business logic at the centre
Every field, validation rule, and case flow lives exclusively in Pega. The external agent knows nothing about them.
Channel agnostic
The same Pega case application serves the web portal, mobile app, and now an AI agent — with zero changes to the application layer.
No channel lock-in
Replacing the Google ADK agent with a different AI framework requires no Pega changes — just point a new A2A-compliant agent at the same endpoint.
Single source of truth
Case state, audit trail, and SLA tracking all live in Pega regardless of which channel initiated the case.
Governed AI
The AI agent cannot bypass Pega’s rules. It cannot submit a screen with missing fields. It cannot skip a stage. Pega’s engine enforces all guardrails.
Architectural Significance: A2A turns Pega’s Centre-Out model into an API for intelligence — any AI agent that speaks A2A becomes a governed, compliant Pega front-end automatically.
5. Why This is the Future
What has been built here is a proof of concept, but the pattern it establishes has profound implications for how enterprises will operate in an agentic AI world.
From Chatbots to Case Engines
The industry has spent years building chatbots that simulate helpfulness — collecting information in conversation and then handing off to a human or a separate system to do the actual work. A2A collapses that gap. The conversation IS the case. Every message advances real work inside a governed enterprise system.
Multi-Agent Orchestration
A2A is designed for agent networks, not just single agents. Imagine a customer service orchestrator agent that triages incoming requests and routes them to specialist Pega agents — one for complaints, one for account changes, one for fraud. Each Pega agent exposes its own A2A endpoint. The orchestrator needs no knowledge of Pega’s internals; it just speaks A2A.
Pega as the Enterprise AI Backend
As AI agents proliferate across enterprises, they will need a governed, auditable, rules-driven backend to execute work. Pega, with its process automation, decisioning, and case management capabilities, is uniquely positioned to be that backend. A2A is the protocol that makes it accessible to the entire agentic ecosystem.
Any Model, Any Framework
This implementation uses Google ADK and Gemini, but A2A is model-agnostic. The same Pega endpoint could be consumed tomorrow by an OpenAI-based agent, a Claude-based agent, or a bespoke enterprise LLM — with no changes to Pega. This vendor neutrality is strategically significant in a market where AI model preferences will shift rapidly.
Looking Ahead: As agentic AI matures, the organisations that will lead are those whose core systems are already agent-ready. Pega’s A2A support means your process backbone is prepared for the agentic era today.
6. Conclusion
This implementation demonstrates that the convergence of agentic AI and Pega’s Centre-Out architecture is not theoretical. The A2A protocol provides the missing link between the rapidly evolving world of AI agents and the governed, process-driven world of enterprise case management.
For us, the implication is clear: Centre-Out was always the right architecture. A2A simply reveals how right it was — and how naturally Pega becomes the intelligent backbone of an agentic enterprise.
Bottom Line: Build your cases in Pega. Expose them via A2A. Let any AI agent in the world drive them. The channel changes; the logic never has to.