Pega GenAI Cookbook: Agentic AI Recipes, Tutorials & Patterns for Enterprise Automation
One Platform. Unlimited Possibilities for Agentic AI.
Pega GenAI Cookbook: hands-on Agentic AI recipes for GenAI Connect, DocAI, MCP, A2A & Knowledge Buddy — governed, production-ready patterns with Gemini, Claude & OpenAI.
What is this page? (read this first)
This Pega GenAI Cookbook is a curated, continuously-updated collection of hands-on Pega Agentic AI tutorials — real recipes, not theory — for building governed, production-ready AI automation on the Pega Platform. It covers Pega Agentic AI, GenAI Connect, DocAI, MCP (Model Context Protocol), Agent-to-Agent (A2A), Knowledge Buddy, Agent Modularization, the Agent Debate Pattern, and Copilot integration, with working examples across Google Gemini, Anthropic Claude, and OpenAI.
Architecture at a Glance — Pega as the Center-Out Intelligence Hub
Pega Agentic AI sits between your systems of record and your AI models, orchestrating every action with full governance and auditability. This is the architectural reason Pega scales where generic agent frameworks stall:
- Pega Agentic AI orchestrates reasoning, planning, and execution across all workflows
- LLM Models (Google Gemini, Anthropic Claude, OpenAI) provide intelligence via Pega’s LLM gateway
- Pega MCP dynamically connects agents to external tools and data sources at runtime
- Pega A2A coordinates with external AI agents (Copilot, Gemini, Claude) across platforms
- Systems of Record receive governed, auditable outcomes from Pega
- Knowledge Sources (SOPs, policies, product docs) feed Pega Knowledge Buddy via RAG
The Pega advantage: this isn’t a point solution bolted onto a chatbot — it’s the intelligent backbone of an entire enterprise automation strategy, with governance built into the architecture, not added as an afterthought.
Why Enterprise AI Fails Without Governed Orchestration
Most agentic AI demos look impressive — until they meet the enterprise. Here’s where generic frameworks break down, and why Pega is built specifically to solve each one:
| Common Failure Mode | How Pega Solves It |
|---|---|
| No governance — agents act without policy enforcement | Every action passes through Pega’s policy and compliance layer |
| No workflow boundaries | Agents operate inside defined, versioned business processes |
| No human approvals | Escalation paths are explicit, configurable case stages |
| No auditability | Every decision is traced, explained, and defensible |
| No SLA management | Native SLA engine catches time-sensitive cases automatically |
| No stateful context | Full case lifecycle context persists across every interaction |
| No deterministic orchestration | Pega guarantees predictable, repeatable outcomes at scale |
This is the single biggest reason to choose Pega Agentic AI over a roll-your-own agent framework: it’s not about limiting what AI can do — it’s about ensuring everything AI does is governed, traceable, and enterprise-ready from day one.
Pega vs. custom frameworks vs. standalone assistants, at a glance
| Feature / Capability | Custom agent frameworks (LangChain / CrewAI) | Standalone LLM assistants (Copilot / custom GPTs) | Pega Agentic AI platform |
|---|---|---|---|
| LLM reasoning |  Included |
Included |
Included (Gemini, Claude, OpenAI) |
| Stateful case management |  Manual database code |
Session-only / transient |
Native, out of the box |
| Enterprise SLA enforcement | Custom microservices |
None |
Native engine & escalation |
| Audit trails & compliance | Custom logging required |
Limited / vendor-specific |
Full lineage & explainability |
| Runtime tool discovery (MCP) | Manual harness |
Model-specific |
Governed enterprise MCP fabric |
Capability Overview: Every Pega GenAI Tool in One Table
| Capability | What It Does | Best For |
|---|---|---|
 Pega GenAI Connect |
Embeds AI insights inline inside Pega UI | Knowledge workers needing real-time AI assistance |
 Pega DocAI |
Extracts & maps data from documents into cases | High-volume document & form processing |
 Pega Agentic AI |
Reasons, plans & resolves cases autonomously | End-to-end intelligent case automation |
 Pega Coach |
Guides agents step-by-step through complex cases | Reducing errors & improving compliance |
 Pega Knowledge Buddy |
Surfaces approved answers from curated knowledge | Self-service portals & contact centers |
 Agent Modularization |
Splits complex agents into focused sub-agents | Scaling & governing enterprise AI systems |
| Pega AI Agent API |
Exposes Pega Agentic AI to external apps via REST | Developers building custom AI-powered portals |
 Agent Debate Pattern |
Runs multiple agents in parallel for high-confidence decisions | Compliance, fraud & high-stakes decisions |
 Agent to Agent (A2A) |
Orchestrates Pega with Gemini, Claude & Copilot | Cross-platform multi-model AI workflows |
 Copilot |
Connects Microsoft Copilot & Power Automate to Pega | Microsoft 365 & Azure OpenAI ecosystems |
 MCP |
Dynamically connects agents to external tools at runtime | Runtime tool discovery without hardcoded integrations |
 Background Processing |
Runs Pega Agentic AI autonomously 24/7 | Real-time batch & SLA-triggered automation |
 GenAI Email Bot |
Reads emails & creates Pega cases automatically | High-volume email triage & routing |
 Proposal Critic Refiner Arbiter |
Multi-agent proposal generation, critique & governed refinement | High-stakes content creation & decision quality |
 Blueprint MCP Server |
Connects Pega Blueprint to any MCP-compatible AI agent | Accelerated application design via AI blueprinting |
 LangGraph SDK + Pega |
Integrates LangGraph stateful agent graphs with Pega workflows | Python-native multi-agent orchestration |
 Infinity '26 Series |
Predictable AI outcomes at a flat fee per resolved case, not per token | Enterprises scaling agentic AI with cost & compliance certainty |
 Tokens — Best Practices |
Prompt caching, data pages, and TOON format for efficient token use | Controlling AI cost and latency at scale |
(Bookmark this table — it’s the fastest way back to any recipe on this page. A condensed copy also appears at the very bottom.)
Why Enterprises Choose Pega for Agentic AI
Pega brings AI reasoning, workflow orchestration, governance, SLA management, and full auditability together in a single platform — so every agent built here is enterprise-ready from the moment it goes live.
- Native multi-agent orchestration — production-grade, not developer-assembled
- Built-in case management — every agent action lives inside a governed case, automatically
- Governance and policy enforcement — native, not bolted on after the fact
- Full audit trail per decision — every action is explainable and traceable
- Native SLA management — time-sensitive cases are caught automatically
- No-code/low-code UI — business users, not just developers, can configure agent behavior
- MCP support built in — agents discover and call tools dynamically at runtime
- Model-agnostic — works seamlessly with Gemini, Claude, and OpenAI
- Regulated-industry ready out of the box — financial services, insurance, and healthcare deployments included
Pega’s LangGraph SDK integration also lets teams bring Python-native agent graph logic inside Pega’s governed case layer — combining flexible agent design with enterprise-grade governance in one workflow.
From here, each section below follows the same easy-to-scan format:
What it is → Key takeaways → Hands-on recipes
(Sections 4–21 continue in this exact structure — reuse your existing content for each capability, but apply this template consistently. Example shown below for one section; repeat the pattern for the rest.)
Pega Agentic AI — The Foundation of This Cookbook
What is Pega Agentic AI? An autonomous AI system embedded natively in the Pega platform that perceives its environment, reasons through multi-step problems, selects and invokes tools, delegates to specialized sub-agents, and drives business outcomes end-to-end — without step-by-step human instruction. It’s model-agnostic, working with Google Gemini, Anthropic Claude, and OpenAI GPT models via Pega’s LLM gateway.
Key Takeaways
- Reasons, plans, and executes — not just responds
- Works natively inside Pega case workflows with zero custom integration
- Supports multi-agent delegation — one orchestrator, many specialized sub-agents
- Powers every other capability in this cookbook — the foundation layer
Hands-On Recipes
- Agentic AI in Case Workflows
- Agentic AI in Self-Service Portals
- Chat with Your Data
- Pega Agents Trigger Case Types and Guide Users to Outcomes
- Configure Data Pages in the Pega Knowledge Tab
- Turbocharge Case Work with Pega Agents and Advanced Tools
- Conversational Agent — Multiple Data Types in Action
- Make Pega Agents Feel Instant: Event Streaming Explained
- Automate Case Intake Process from Attachments
- Agentic AI Demo on Handling Order Fallout in Communications
- AI Tracer for Every Agent
- Generate or Decide? Knowing When to Use Pega GenAI Connect vs. Agent
- Enterprise Model Benchmark Pattern: Comparing AI Models Through Pega
- From Duplicate Chaos to Instant Clarity — Pega’s AI-Powered Case Workflow
“AI generates possibilities. Pega governs execution.”
GenAI Connect:
What is Pega GenAI Connect? It embeds LLM-powered intelligence directly into UI components, case stages, and workflow steps — surfacing AI suggestions, summaries, and automation actions inline, with prompt redaction for data privacy. Works with Google Gemini, Anthropic Claude, and OpenAI via Pega’s LLM gateway.
Key Takeaways
- Embeds AI suggestions and summaries directly into the Pega UI — no context switching
- Supports prompt redaction to protect sensitive data before it reaches the LLM
- Tunable responses — adjust tone, length, and format without redeploying
- Works with any LLM connected via Pega’s gateway (Gemini, Claude, OpenAI)
Hands-On Recipes
- Effortless Intelligence in the Flow
- Pega GenAI Prompt Redaction
- Real-Time Tuning for GenAI Connect Responses
- Call GenAI Connect Rule in Case Workflow
Pega DocAI: Document Extraction Tutorial
What is Pega DocAI? An intelligent document processing capability that uses LLMs to automatically extract structured data from unstructured documents — PDFs, scanned forms, invoices, contracts — and map it directly into Pega case fields. Integrates with Pega Agentic AI for fully automated document-to-case workflows; supports Google Gemini and OpenAI extraction models.
Key Takeaways
- Extracts structured data from PDFs, scanned docs, invoices, contracts, and forms
- Maps extracted fields directly into Pega case data — no manual re-entry
- Combines with Pega Agentic AI to create fully automated document-to-resolution flows
- Validated for regulated industries: financial services, insurance, healthcare
- Token tip: extract only the fields your case actually needs rather than the full document text — large multi-page PDFs are the single biggest token-cost driver in agentic workflows
Hands-On Recipes
- Next-Level Document Automation with DocAI, Powered by Pega GenAI
- Autopilot Your Docs: Streamline Processing with Pega DocAI
Pega Knowledge Buddy Tutorial: RAG Setup Guide
What is Pega Knowledge Buddy? A GenAI-powered knowledge retrieval assistant built into the Pega platform. It uses retrieval-augmented generation (RAG) to surface accurate, organization-approved answers from curated knowledge sources — internal policies, product docs, SOPs — in real time, inside agent desktops and self-service portals.
Key Takeaways
- Uses RAG (Retrieval-Augmented Generation) — grounded answers, not hallucinations
- Sources curated from internal knowledge bases, PDFs, SOPs, and product docs
- Pega Agentic AI can query Knowledge Buddy proactively mid-case workflow
Hands-On Recipes
- Configuring Knowledge Buddy and Agentic AI
- Unleashing the Magic of Pega Knowledge Buddy and Conversation Agent
- Pega GenAI Knowledge Buddy: Your Magic Compass
- Knowledge Buddy Collections & Data Sources Setup Guide
- The Intelligence Layer Between Enterprise Knowledge and Agentic AI
Pega Coach
What is Pega Coach? An AI-powered guidance engine that delivers step-by-step, context-aware answers to case workers in real time — helping them navigate complex cases, compliance requirements, and product questions without escalation. Powered by the same LLM infrastructure as the rest of Pega GenAI.
Key Takeaways
- Delivers real-time, step-by-step guidance inside the Pega agent desktop
- Context-aware — responses adapt based on the current case stage and data
- Reduces agent training time and compliance risk simultaneously
- Complements Pega Agentic AI — Coach guides humans, Agentic AI handles autonomous steps
Hands-On Recipes
Agent Modularization: Multi-Agent Design Pattern
What is Agent Modularization? A Pega Agentic AI design pattern where a central orchestrator decomposes complex business processes into smaller, focused sub-agents — each independently developed, tested, versioned, and scaled. The recommended pattern for production deployments; different LLMs can be assigned per sub-agent.
Key Takeaways
- Separates concerns — each sub-agent does one thing well and is independently testable
- Central orchestrator routes tasks dynamically based on context and outcome
- Reduces regression risk — update one sub-agent without affecting others
- Enables different LLMs per sub-agent (e.g., Gemini for summarization, Claude for reasoning)
- Recommended pattern for enterprise-grade Pega Agentic AI production deployments
Hands-On Recipes
AI Agent API: REST API Tutorial & Code Examples
What is the Pega AI Agent API? A RESTful interface that exposes Pega Agentic AI capabilities to external applications — initiating agent sessions, sending user messages, receiving streamed responses, and managing stateful multi-turn conversations from outside the Pega UI. Compatible with ChatGPT, Gemini, and Claude integrations.
Key Takeaways
- RESTful API — integrate Pega Agentic AI into any external app or portal
- Supports stateful multi-turn conversations with session management
- Enables React, Angular, mobile, and third-party frontends to leverage Pega agents
- Pega handles all backend orchestration — developers focus on UX
- Token tip: long-running multi-turn sessions accumulate conversation history — periodically summarize or trim older turns instead of resending the full session history with every call
Hands-On Recipes
How to Build Multi-Agent Systems in Pega: The Agent Debate Pattern
What is the Agent Debate Pattern? An advanced pattern where multiple independent AI agents simultaneously reason about the same problem from different perspectives — then a central orchestrator synthesizes the best final answer. Demonstrated using Google Gemini with temperature-controlled reasoning for diversity of thought before convergence.
Key Takeaways
- Multiple agents reason in parallel — different perspectives, same question
- Orchestrator synthesizes a final answer from competing agent outputs
- Temperature tuning via Gemini controls reasoning diversity between agents
- Ideal for compliance decisions, fraud assessment, and loan underwriting
- Demonstrated with Google Gemini — compatible with other LLMs via Pega’s gateway
Hands-On Recipes
- Parallel AI Reasoning, One Decision: Pega’s Agent Debate Pattern
- Pega MCP Agent Debate Pattern Using Gemini: Temperature Driven Intelligence at Scale
- Pega MCP Agent Debate Pattern: Governing Multi-Agent Intelligence at Enterprise Scale
How to Build Multi-Agent Systems in Pega: The Proposal Critic Refiner Arbiter Pattern
What is the PCRA Pattern? An advanced design pattern for high-stakes content generation: a Proposer agent drafts a response, a Critic agent evaluates it against quality/compliance standards, a Refiner applies the critique, and a governed Arbiter selects the best output or signals further iteration — all within a Pega case workflow with a full audit trail. Compatible with Gemini, Claude, and OpenAI.
Key Takeaways
- Four-role architecture: Proposer → Critic → Refiner → Arbiter, each independently configurable
- Arbiter role enforces governance — outputs only leave the loop when they meet defined standards
- Full Pega case lifecycle integration — every iteration is traceable, auditable, and SLA-governed
- Compatible with all major LLMs via Pega’s gateway; assign the strongest reasoning model to the Arbiter role
- Reduces hallucination risk in high-stakes outputs: contracts, compliance documents, medical summaries, financial proposals
- Supports human-in-the-loop escalation when the Arbiter cannot reach a passing threshold
Hands-On Recipes
Pega Agentic Fabric
What is Pega Agentic Fabric? The unified orchestration layer positioning Pega as the central intelligence hub for enterprise Agentic AI — connecting intelligent agents, workflows, data/APIs, business decisions, policies, and human-AI collaboration into one coordinated, governed platform, whether agents are Pega-native or external (Gemini, Claude, Copilot).
Key Takeaways
- Pega Agentic Fabric is the enterprise brain — a unified layer connecting agents, workflows, data, decisions, and governance across the organization
- Manages the full workflow across specialized agents (Fraud Agent, Loan Advisor, Knowledge Agent, Debate Pattern Agent) as one connected system
- MCP connectivity enables secure, standardized, reusable integration with external AI providers and enterprise systems — with less custom development
- Policy-based governance built in — every agent action is explainable, auditable, compliant, and subject to responsible AI controls
- Enables enterprises to move beyond isolated AI pilots toward enterprise-wide AI transformation
Hands-On Recipes
Blueprint MCP Server: Pega MCP Tutorial
What is the Pega Blueprint MCP Server? It exposes Pega Blueprint — Pega’s AI-powered application design assistant — as an MCP server endpoint, letting any MCP-compatible AI agent or IDE (Claude, Gemini, OpenAI-powered tools) discover and invoke Blueprint capabilities at runtime: generating case type hierarchies, data models, and UI specs from natural language, without a human operating the Blueprint UI.
Key Takeaways
- Exposes Pega Blueprint as an MCP server — callable by Claude, Gemini, OpenAI, and any MCP-compatible agent
- Enables agent-driven application design: natural language → Pega case types, data models, UI specs, automatically
- No hardcoded integration required — agents discover Blueprint tools dynamically at runtime via the MCP protocol
Hands-On Recipes
LangGraph SDK + Pega
What is LangGraph SDK + Pega? An integration pattern connecting LangGraph’s stateful, Python-native agent graphs with Pega case workflows — enabling self-healing multi-agent orchestration that combines LangGraph’s graph-based agent logic with Pega’s governance layer.
Hands-On Recipes
Pega Agent-to-Agent (A2A) Integration Tutorial: Connecting Gemini, Claude & Copilot
What is Agent to Agent (A2A) in Pega? A governed communication protocol enabling Pega Agentic AI to act as the central orchestrator — sending tasks to, receiving results from, and collaborating with external AI agents from other platforms. Validated A2A integrations with Google Gemini, Anthropic Claude, and Microsoft Copilot.
Key Takeaways
- Pega acts as the central AI orchestrator — Gemini, Claude, and Copilot are workers
- Standardized message schema enables cross-platform agent collaboration
- Validated integrations: Google Gemini, Anthropic Claude, Microsoft Copilot, Power Automate
- Pega governs all handoffs — audit trail, security, and outcome tracking maintained
- Enables React-based self-service portals powered by Pega’s agentic backend
Hands-On Recipes
- What Is Agent to Agent (A2A)?
- Configure Agent-to-Agent (A2A) Communication
- Agent to Agent Intelligence (Pega and Gemini)
- Pega as the Agentic Brain: Powering React-Based Self-Service with Agentic AI
- Powering Enterprise Automation with Pega, Gemini, and Claude
Copilot Integration
What is Pega Copilot integration? Pega’s Copilot integration connects Microsoft Copilot — embedded in Microsoft 365, Teams, and Power Automate — to Pega’s case management engine via the A2A protocol, letting Copilot users trigger Pega workflows and receive Pega-driven outcomes inside their Microsoft productivity environment.
Key Takeaways
- Microsoft Copilot triggers Pega workflows via A2A — no custom middleware needed
- Power Automate flows can create and update Pega cases through the same pattern
- Relevant for Microsoft 365, Teams, Azure OpenAI, and Copilot Studio ecosystems
- Pega handles all case logic and governance — Copilot handles the conversation
Hands-On Recipes
- Copilot × Pega A2A Orchestration
- Copilot Working with Pega via A2A Orchestration
- Pega-Powered A2A Integration with Microsoft Power Automate
- Configuring Email-Driven Pega Agentic Workflows
- Transforming Email into Action with Pega & Copilot Agentic AI
MCP — Model Context Protocol: Pega MCP Tutorial
What is MCP in Pega? The Model Context Protocol — an open standard originally developed by Anthropic — defines how AI agents discover and invoke external tools, APIs, and data sources at runtime. Pega’s MCP integration lets Pega Agentic AI agents dynamically connect to any MCP-compatible tool server without hardcoded integrations.
Key Takeaways
- MCP is an open standard (Anthropic-originated) — now supported by all major LLM providers
- Pega agents discover and invoke tools dynamically at runtime — no hardcoded integrations
- Compatible with Claude, Gemini, and OpenAI tool-use and function-calling patterns
- Enables Pega to connect to any MCP-compatible data source, API, or service
- Supports the Agent Debate Pattern — multiple agents use different MCP tools in parallel
- Token tip: a
tools/listcall returns every tool’s full schema — cache the tool list per session instead of re-fetching it on every agent turn to cut redundant token overhead
Hands-On Recipes
- What Is MCP — and How Does It Work?
- Pega Agentic AI with MCP: Orchestrating Multi-Agent Intelligence the Enterprise Way
- Agent Synthesis with Pega MCP: Orchestrating Enterprise AI Agents
Background Processing
What is Pega Agentic AI Background Processing? The ability to run AI agent workflows asynchronously — triggered by Pega Queue Processors or SLA escalations — without any user initiating the session. The agent executes its full reasoning-and-action loop silently in the background, compatible with Gemini, Claude, and OpenAI.
Key Takeaways
- Agents run asynchronously — no user session required to trigger AI processing
- Queue Processors enable high-volume batch AI execution across thousands of cases
Hands-On Recipes
- Pega Agentic AI: Run AI in the Background with Queue Processors
- Pega Agentic AI: Run AI in the Background with SLAs or Wait Shape
GenAI Email Bot
What is the Pega GenAI Email Bot? An AI-powered email processing agent that reads incoming emails, understands intent using an LLM, and automatically creates Pega cases, triggers workflows, and generates contextually appropriate responses — without human intervention. Leverages Pega Agentic AI reasoning; compatible with Gemini, Claude, and OpenAI.
Key Takeaways
- Reads and understands email intent using LLM — not keyword matching
- Automatically creates Pega cases and triggers workflows from inbound emails
- Generates contextually appropriate responses — reducing agent reply time to zero
- Handles multi-request and ambiguous emails with Pega Agentic AI reasoning
Hands-On Recipes
- Pega Agentic AI Email Bot: Intelligent Responses and Case Creation from Email
- Pega Agentic AI Email Bot: Turning Emails into Intelligent Business Outcomes
Infinity '26 Series — Predictable AI at Enterprise Scale
What is Pega Infinity 26? Pega’s newest platform release, generally available since July 2026. It’s Pega’s full AI suite built around one core promise: enterprises can scale agentic AI while keeping outcomes and costs predictable. Announced at PegaWorld 2026, its core innovation areas include predictable outcomes with predictable costs, alongside new agentic orchestration and design tooling.
What’s actually new in this release:
- Pega Infinity Studio — an AI-native development environment that pairs your coding agent of choice with built-in best practices from Pega Blueprint AI, aimed at faster, more reliable delivery of mission-critical apps.
- Predictable AI agents and orchestration — new agentic capabilities let developers connect and orchestrate both Pega and third-party AI agents inside governed workflows, so agents can be added to mission-critical processes without losing control, compliance, or predictable outcomes.
- Design and runtime MCP — clients can now use MCP to connect Pega Blueprint, Pega Infinity Studio, and Pega Platform to build applications with preferred agentic coding harnesses like Claude Code, GitHub Copilot, and OpenAI Codex, and to invoke agents and workflows from assistants like Claude Cowork, ChatGPT, and Microsoft 365 Copilot.
- Pega Customer Engagement Studio — an agent-powered workspace unifying AI agents to help marketers move from brief to live, personalized 1:1 campaigns in minutes at scale, with built-in governance.
- Available through Pega Cloud or in a client’s own managed cloud, within an open MCP-compatible ecosystem that lets enterprises use other AI models or agents without giving up control.
Why it matters for this cookbook: every recipe above — GenAI Connect, DocAI, A2A, the Debate Pattern, Agentic Fabric — now runs on a platform explicitly engineered to make agentic AI’s two biggest enterprise blockers, unpredictable outcomes and unpredictable costs, disappear. As Pega’s chief product officer put it, the next phase of AI adoption is about scaling results with confidence, by building governance into AI-driven workflows and aligning pricing with completed work.
Key Takeaways
- Infinity Studio brings AI-native, agent-assisted development directly into the platform
- MCP now works at both design time and runtime, opening the door to Claude Code, GitHub Copilot, OpenAI Codex, Claude Cowork, ChatGPT, and Copilot as first-class integrations
- Third-party agents can now be orchestrated alongside Pega-native agents in the same governed workflow
Hands-On Recipes
- Pega Infinity™ ’26 MCP Server and Pega 25.1.3 MCP Connect
- Connecting GitHub Copilot and Building Stages with Pega AI Assistant
Tokens — Best Practices
What is token optimization in Pega Agentic AI? Every call to an LLM — reasoning, tool use, document extraction, RAG retrieval — consumes tokens, and token volume is the primary driver of both cost and latency in agentic systems. Pega provides several native mechanisms (data pages, prompt caching, structured formats like TOON) to keep token consumption efficient without sacrificing agent capability, on top of the flat-fee model introduced in Infinity 26.
Key Takeaways
- Understanding how tokens accumulate — across reasoning steps, tool calls, and conversation history — is the first step to controlling AI cost at scale
- Prompt caching (static vs. dynamic) can dramatically cut repeated token spend for stable context that doesn’t change turn-to-turn
- Data pages let agents reference structured data by pointer instead of re-sending full payloads with every call
- TOON (Token-Oriented Object Notation) is a more compact structured format than raw JSON for high-fidelity agent communication — fewer tokens for the same information
- These practices compound with Infinity 26’s flat-fee-per-resolved-case pricing — lower token usage per call means more headroom under a fixed cost ceiling
Hands-On Recipes
- Token Economy: How AI Really Thinks, Costs, and Scales
- Static vs Dynamic Prompt Caching
- Optimizing Tokens in Pega Agentic AI Using Data Pages
- TOON — A Smarter Way to Build High-Fidelity AI Agents
- Pega Conversational AI Agent: What Belongs in a Prompt vs. a Pega Rule
- Rules vs. Models vs. Agents: Drawing the Line in Pega
General: Token Optimization & Exception Handling
What does the General section cover? Broad Pega GenAI capabilities that apply across all implementations — from handling exceptional or unstructured case scenarios dynamically (Ad Hoc Cases), to optimizing how your Pega application manages LLM token consumption to control cost and latency at scale. Essential reading before taking any Pega GenAI solution to production. All optimizations apply across Gemini, Claude, and OpenAI.
Key Takeaways
- Ad Hoc Cases let Pega Agentic AI handle exceptions that don’t fit standard case types
- Data Transform optimization reduces token payload — directly cuts LLM API costs
Hands-On Recipes
“Every recipe in this cookbook proves one thing: Pega doesn’t just add AI — it makes AI enterprise-ready.”
“The future of enterprise AI is not standalone agents operating without boundaries. The future is governed intelligence orchestrated through enterprise workflows.” — and Pega is the platform built to deliver exactly that.
Updated May 26, 2026 — Pega Agentic AI cookbook now includes: Architecture at a Glance, Why Enterprise AI Fails Without Governed Orchestration, and Key Takeaways across all 14 Pega GenAI capability sections.