Learn how to bring your bots into the future on Customer Service 26.1 with Agentic Messaging
A customer opens the chat widget on your bank’s site and types: I moved last month and my statements are still going to my old place. A topic-driven bot has to match that sentence against a topic somebody configured in advance. When the keyword table covers the phrasing, the customer gets a conversation flow and a case gets created. Drift far enough from what was configured and the bot returns a non-match, which starts a counter running toward escalation.
An Agentic Messaging channel routes that same sentence to a large language model carrying a role and a set of constraints, along with an explicit list of the case types it may start. The model reads the request as an address change. It then starts the real Pega case through a tool call, using whatever context the session handed it, and no keyword table in the application ever had to contain that phrasing.
This article covers what Agentic Messaging is, how the runtime path works from the widget through to the model and back, what you configure on the Agent rule, how topic-driven Digital Messaging compares, and where to look when you want to see what a conversation actually did.
1. What Agentic Messaging is
Pega Customer Service ships three Agentic self-service channels: Agentic Messaging, Agentic Voice, and Agentic Email. An Agent holds the behavior in all three, and the channel gives that Agent a way to reach customers. Agentic Messaging and Agentic Email run on Customer Service on Constellation, while Agentic Voice is scoped more broadly and supports both Customer Service and Pega Platform implementations.
Agentic Messaging moves self-service past the rule-based chatbot. Each conversation goes to an AI cognitive framework embedded in an Agent rule, and that framework adapts as the customer’s request develops, drawing on account context and starting real work in the application. Introduction to Agentic Messaging, Voice, and Email carries the conceptual walkthrough.
Two naming notes before going further. The conceptual material calls this an Agent rule and the how-to material shortens it to Agent, for the same thing. The second note concerns the abbreviation MCP. In a chat and messaging context, MCP refers to the older multichannel naming, which is where class names like Data-Decision-Request-MCP-BotAgent come from and why the legacy 8.x help content sat under an /mcp/ path. Model Context Protocol is a separate capability with its own rule types. A search for MCP across messaging content returns both, so check which one a page means before you act on it.
Note on UI-Kit applications. Product development has focused on delivering the core use cases in Constellation. UI-Kit applications can leverage Constellation views to enable the capability today, with some UI-Kit limitations remaining. Broader UI-Kit coverage is planned in a future patch release.
2. How topic-driven Digital Messaging works
The topic-driven path is worth understanding, partly because it makes the agentic one easier to reason about, and partly because a great many production estates still run it.
A Digital Messaging channel routes inbound text through a Text Analyzer. The Text Analyzer rule provides sentiment, categorization, text extraction, and intent analysis, and it requires the Pega-NLP ruleset in the application stack. Supporting models arrive as Decision Data rules on classes including Data-NLP-Taxonomy for classification, Data-NLP-Intent for intent, Data-NLP-EntityModels and Data-NLP-Rule for entity extraction, and Data-NLP-SentimentModels alongside Data-NLP-SentimentLexicon for sentiment. Entity extraction rules are uploaded as Apache Ruta scripts.
On the channel interface, the Behavior tab carries a Text Analyzer section where you enable Use advanced configuration and add an analyzer. Three types are available. Exact match is the default and matches user input to a response exactly. Pega NLP uses the analyzer models above. iNLP is the advanced option, built on a text prediction. Each analyzer is scoped to run inside a case context, outside one, or both. The same section carries Enable Knowledge Buddy and a Knowledge Buddy name, so a topic-driven channel can reach curated content without a topic match.
Figure 1. Use advanced configuration enabled, with all three analyzer types stacked and each scoped to apply inside and outside case context. Note that Edit topics hangs off the iNLP row, and the Pega NLP row points at a named analyzer rule.
Edit topics is where the configuration accumulates. Each topic gets a table, maintained per language, with columns for Topic, Approximate match, Must match, and Never match. Every suggested case in the system is a topic, so the table grows in step with your case inventory, and supporting Spanish means writing every keyword variant a second time in Spanish.
Figure 2. The topic table for an insurance virtual assistant. Each row is one topic and its keyword variants, including operational entries such as escalate, greeting, and dont trigger. This is the artifact an Agent rule replaces with prose.
Once a topic matches, a conversation flow takes over on a flow canvas built from three smart shapes: Ask a question, Send a message, and Conversation flow. The Ask a question shape carries most of the design. Its Question type accepts Open ended, Buttons, Quick replies, or Yes or No. You set Save response to the field, optionally an Entity to extract, a Validation error message, and a Number of repeats running from one attempt up to Until successful. Three hard constraints apply to the underlying business case: it cannot contain user interface forms, it must generate at least one question, and it must reach Resolved status or be reassigned to another operator.
Figure 3. A claims assistance conversation on the flow canvas. Every turn the customer will experience is drawn here in advance, including the order the questions arrive in and where the flow hands off.
When the analyzer stops matching, escalation fires. In App Studio under Settings then Chat and messaging, Bot failure escalation carries a Consecutive non-matches threshold that ships at 3.
Figure 4. Chatbot response failures will escalate to an CSR with Consecutive non-matches set to 3. Three unrecognized phrasings hand the conversation to a person.
For what it was built to do, this is sound engineering. Execution is deterministic and inexpensive to run, and it audits cleanly in a compliance review. What the agentic model changes is the rate at which you can add journeys. Adding one to a topic-driven channel means a taxonomy update, keyword variants in every supported language, a conversation flow, and a regression pass across the topics you already had.
3. Where the reasoning happens now
The Agent rule stands in for the taxonomy and the conversation flow together. You author it in Infinity Studio under Create, then Generative AI, then Agent. It is a first-class rule type, versioned and checked in like any other rule.
What goes into it is prose plus an allow list. The prose establishes the role and the constraints, and in the allow list you name the case types the Agent may start along with the data it may read. At runtime the model reads the customer’s message alongside the conversation so far and whatever context the data pages supply, then selects a tool. Execution of that tool follows the case lifecycle and access control already defined in the application.
The practical consequence is that prompts cannot bypass the Pega flow engine. If your address change case requires verification before it advances a stage, no phrasing from the customer moves it past that gate, because the gate lives in a rule and the model only gets to ask for the transition.
Figure 5. The same customer message entering both engines. In the top lane the outcome is settled by whether a keyword table was written to cover the phrasing. In the bottom lane the Agent rule bounds what is reachable and the model chooses from inside those bounds on every turn, carrying the conversation forward with it.
The loop in the bottom lane is the part that changes day-to-day work. A topic-driven channel resolves each message against configuration and then follows a drawn path. An agentic channel re-enters the Agent rule on every turn with the full conversation attached, so the decision about what to do next is made with everything the customer has already said.
4. The architecture
Figure 6. Runtime path for an Agentic Messaging conversation, from the customer channel through Digital Messaging Service into the Agent rule, tool execution against Pega rules, and the response path back out. The Digital Messaging channel appears in lane 4 for context, because the same Digital Messaging Service serves both engines.
Digital Messaging Service connects to a service package containing authentication and REST service components, and it links to both the Agentic self-service and the Digital Messaging engines. Messages storage and the send API carry the response back out.
Reading the diagram from the top:
Lanes 1 and 2. The customer channel terminates at Digital Messaging Service on Pega Cloud. DMS normalizes every connector to a single message shape, and Digital Messaging Manager is where connections are created and where the install snippet and JWT secret come from.
Lane 3. DMS reaches the Pega application through a service package pairing authentication with a REST service.
Lane 4. Channel type decides which engine answers, and because DMS links to both engines the transport underneath is genuinely shared, with the choice made at channel creation time.
Lane 5. The Agent rule, broken down field by field in section 5.
Lane 6. Tool execution, where everything the Agent actually accomplishes happens, across case types, data pages, Knowledge Buddy retrieval, and escalation to a live CSR.
Lane 7. The response leaves through messages storage and the send API, back out through DMS to the channel.
Right column. The model call goes out through the Pega GenAI Gateway, which runs under strict single-tenant isolation with a dedicated gateway, vector store, and agent service for each client environment, and applies content filtering across prompts and responses. Observability lands in a conversation case with a PXCONV- prefix, covered in section 8.
Prior Web Messaging experience carries over more than you might expect. The Template operator, the Base URL, Digital Messaging Manager, and the JWT secret are the same mechanisms a Digital Messaging channel uses.
5. Configuring the Agent rule
Create the Agent before the channel, because the channel asks you to select one.
In the Infinity Studio header, click Create, select Generative AI, then Agent. Give it a Label. In the Scope section, choose whether the Agent applies to your current application, a Case Type, or Other. The example used through the rest of this section is a U+ Bank address change agent, scoped to Case Type with Address change selected in the Applies To list.
The rule form then opens on Definition.
| Tab | Section or field | What it controls |
|---|---|---|
Definition |
Agent instructions |
The role the Agent assumes and the outcome it drives toward. Example: “You are a smart, conversational AI assistant for the U+ Bank Customer Service self-service portal.” |
Definition |
Guardrails |
Validation and scope statements. Example handling out-of-domain input: “When a user asks for information outside of your domain, politely remind them of your domain of expertise.” |
Definition |
Response Style & Tone |
Register and verbosity. Example: a soft, empathetic tone, plain language over backend field names, and confirmation of details in a single sentence before moving on. |
Definition |
Additional context |
Data pages the Agent reads while generating every response. Add Data page takes a descriptive Name, the data page itself, and optionally an Apply Data Transform to narrow which fields are exposed. |
Definition |
Conversation start |
How the chat opens. A Greeting waits for the customer to speak first, an Opening Message sends automatically. New in 26.1. |
CASE TYPES |
Tool section |
The allow list of work the Agent may initiate and process at run time. |
Knowledge |
Buddy |
A Pega GenAI Knowledge Buddy for retrieval-grounded answers. Optional. |
SETTINGS |
Model |
The model alias the Agent runs on. |
Several of these deserve more than a table row.
Additional context and the data transform. The example adds D_pxDMSContextData to carry context from the website into the platform. Customer data stays in Pega, where the logic for retrieving and exposing that data is defined. The optional Apply Data Transform field is where you control which properties actually reach a prompt. If an account object carries fifteen properties and the Agent needs four of them, the transform is where you say so, and it is the natural home for role-based restrictions on prompt content.
Conversation start. Customer Service 26.1 adds a Conversation start section, sitting on the same tab below Additional context, that decides how the first turn happens. Greeting (wait for user input) shows a short opener such as “How can I help you?” and then waits, which suits a widget the customer opened deliberately. Opening Message (send automatically) pushes the first message without waiting. That fits proactive chat and deep links from a page where you already know why the customer arrived.
Figure 7. Conversation start on the Agent rule Definition tab, directly under Add Data Page. The Greeting field is a picker, and a ruleset with nothing in it yet shows No items with Create new beneath.
Create new opens a New Dynamic Text dialog taking a Name and the Text itself. The editor accepts inserted property references, so the greeting resolves per customer when the chat opens.
Figure 8. A dynamic greeting under construction. [First Name] is a property reference resolved at run time, and the </> control in the corner of the editor switches the field to source view.
Two operational details belong on the build ticket. Anything past 200 characters is trimmed automatically, so a greeting that grows with a customer name or an account descriptor can lose its ending in production while looking correct in a demo. Preview a dynamic greeting before publishing, since this is the one message in the conversation that no guardrail or tone setting gets a chance to reshape.
Case types and tools. On the CASE TYPES tab you select a case type, then click Add in the Tool section and pick that case type again, which enables the Agent to initiate and process it at run time. Click +Add and select Interaction to initiate an interaction with the Agent.
Figure 9. The CASE TYPES tab on an Agent rule. The on-form guidance states that the listed Case Type sources are invoked based on the user’s question with only the relevant ones used to answer, and that the Agent starts and handles a Case until it is routed to a different user. Interaction sits alongside the business case type in the same list.
Importing an application from Pega Blueprint automatically creates an application agent along with case type tools, each carrying a description. Those descriptions are the signal the model uses when it decides which tool fits a request, so the quality of that text determines how reliably the right workflow starts.
Model. The Model Availability Dashboard publishes the aliases Pega-Default-Smart, Pega-Default-Fast, and Pega-Default-Embedding, alongside a Pega-Blueprint-Models grouping. Pega-Default-Fast currently maps to Claude Haiku 4.5. Underneath the aliases, models run on AWS Bedrock, Azure OpenAI, and Google Cloud Vertex AI. Deprecation surfaces through two PDC alerts: PEGA0175 for a model nearing its deprecation date, and PEGA0176 for one that is no longer available. Check the dashboard when you choose an alias, because the mappings move between releases.
Temperature is a GenAI Connect rule setting, found under Advanced then Model. GenAI Connect is a separate rule type used for single-shot generation.
5.1 What changes in Customer Service '25
If you are on '25, the authoring surface differs enough to matter:
| '25 | '26 |
|---|---|
AI Designer > agent > Create new Agent |
Infinity Studio header > Create > Generative AI > Agent |
Agent name plus a separate Description |
Label |
Scope offers application or Case Type |
Scope adds Other |
No Tool section. The system creates the Tool Rule in the background |
Explicit Tool section on CASE TYPES, plus the Interaction step |
Starter question and Quick-Select Question sections |
Both dropped |
Model shown as a raw name, Claude-35-Sonnet |
Model shown as an alias, Pega-Default-Fast |
The tools delta is the one to watch during an upgrade, because implicit tool creation becoming explicit changes what an upgraded Agent rule looks like on the form.
6. Creating the Agentic Messaging channel
With the Agent saved and checked in:
- In Infinity Studio, go to
Channels, open the channels landing page, and clickCreate new channel. SelectAgentic Messaging. - On the
Overviewtab, setChannel nameandChannel description. UnderAgent settings, select your Agent from theAgentlist.
Figure 10. Agent is a required field, and the section links straight out to AI Designer if the Agent still needs work.
3. On the Configurations tab, in the Connections section, set the Template operator and confirm the Base URL points at your instance. Save. The Manage connections button appears once the details are saved.
Figure 11. Template operator and Base URL are both required. Existing connections list underneath with their profile ID and last updated timestamp.
5. Click Manage connections to open Digital Messaging Manager.
Figure 12. Digital Messaging Manager opens on DEVELOP with the connection list and Add connection. MONITOR and CONFIGURE sit alongside it.
6. Click Add connection and choose the channel tile. On the General tab, set Name and Chat heading, then save.
Figure 13. Chat headings are per language, and the widget configuration checkboxes live on this same tab below Sound notifications. Enable web socket health check and Enable voice-to-text are the 26.1 additions.
7. On the Installation tab, copy the URL from the src parameter. On the Security tab, click Show JWT Secret.
Figure 14. The Installation tab hands you a complete script tag to place above the closing body tag. The value you need for a Constellation site is the src URL inside it.
8. On the consuming site, paste those two values into the fields for the Digital Messaging server URL and the JWT secret. The chat icon can take a few seconds to appear.
The Template operator deserves care. It is the template from which each user’s auto-created account is cloned, and it needs at minimum the PegaRULES:User4 access role to reach the application’s cases. Give that account the scrutiny you would give any service account with case creation rights, because every conversation runs under something cloned from it.
Each user of an Agentic Messaging channel maps to a separate operator and user account, created on first interaction. If a user clears browser cache or cookies, the previously auto-generated account may no longer be identifiable and the system creates a new one, which is worth knowing before you read anything into operator counts in a test environment.
Widget options are configured in Digital Messaging Manager and carry over from Web Messaging, including Enable emoji picker, Display typing indicator, Allow customer to upload and send attachments, and the Choose when to play sound behavior. Customer Service '26 adds Enable web socket health check and Enable voice-to-text.
6.1 Quick reference
| Step | Where | Key setting |
|---|---|---|
| Create the Agent | Infinity Studio, Create > Generative AI > Agent |
Label, Scope, Applies To |
| Author behavior | Agent rule, Definition tab |
Agent instructions, Guardrails, Response Style & Tone |
| Grant data | Agent rule, Definition > Additional context |
Add Data page, optional Apply Data Transform |
| Grant work | Agent rule, CASE TYPES tab |
Tool section, plus Interaction |
| Ground answers | Agent rule, Knowledge tab |
Buddy |
| Pick the model | Agent rule, SETTINGS tab |
Model |
| Create the channel | Channels > Create new channel > Agentic Messaging |
Agent settings > Agent |
| Wire the transport | Channel, Configurations > Connections |
Template operator, Base URL |
| Add the connector | Manage connections > Digital Messaging Manager |
Add connection, Installation, Security |
7. Digital Messaging and Agentic Messaging side by side
| Concern | Digital Messaging channel | Agentic Messaging channel |
|---|---|---|
| Understanding input | Text Analyzer with taxonomy, intent, and entity models from the Pega-NLP ruleset |
Large language model reasoning over the message and conversation history |
| Primary config artifact | Topic keyword tables and conversation flows on a canvas | Agent instructions, Guardrails, Response Style & Tone as prose |
| Adding a journey | New topic, keyword variants per language, new conversation flow, regression on existing topics | Add the case type as a tool, with a description the model can select on |
| Multi-language | Keyword tables maintained per language | Handled by the model, subject to your tone instructions |
| Off-topic input | Consecutive non-matches counter, default 3, then escalation |
Guardrail prose redirects the customer back to the domain |
| Grounding | Pega Knowledge suggestions, historically surfaced to the CSR | Knowledge Buddy retrieval available directly to the Agent |
| Conversation control | Explicit flow, Ask a question shapes, Number of repeats |
Model-driven turn taking within the guardrails |
| Case execution | Flow steps in the conversation | Tool call into the real case type |
| Determinism | Fully deterministic path | Deterministic execution, probabilistic routing to it |
| Transport | Digital Messaging Service | Digital Messaging Service, unchanged |
Both engines coexist, and each channel type is created separately, so the two can suit different classes of business problem inside the same estate. A topic-driven channel that already performs well can stay where it is, and the agentic channel is where new self-service journeys go.
8. Observability and testing
Every GenAI Agent execution creates a conversation case on class Pega-Autopilot-Conversation with the PXCONV- prefix, and that case acts as the memory for the agent. When you query these cases, filter design-time rows out by excluding pyAssistantName values of pzDevAutopilot.
The property to know is pyStateJSON, which holds granular metrics for each signal and action, including the tool, its duration, token count, retry count, and the model used. The data page D_pxAgentMetrics transforms that raw data into a Pega object structure and feeds the tracer view.
The tracer attributes token consumption down to the individual agent, tool call, or data retrieval, and duration down to the agent, tool, or LLM call. The same capability appears as Agent Tracer in some material and AI Tracer in others, so search on both if you go looking for it.
Testing runs end to end through the live widget. Use one utterance inside the Agent’s domain and one outside it, which exercises the happy path and the guardrail in a single pass. The fee inquiry challenge pairs “I have just noticed a late fee on my account and wondering if it could be waived?” with “I would like to increase my credit limit.” Build an utterance set on that pattern early and keep it in version control alongside the Agent rule, so a prompt edit gets the same regression treatment as a flow change. There is also an open-source evaluation framework at pegasystems/infinity-ai-agent-demonstrations combining an LLM-judge track with a rules-based deterministic track, which is a faster start than writing a harness from scratch.
9. Reference
- Introduction to Agentic Messaging, Voice, and Email
- Creating an agent for an Agentic Messaging interface
- Setting up an Agentic Messaging interface and Web Messaging channel
- Enhancing self-service AI experience with Agentic Messaging, module
- Configuring a self-service agent, adding a fee inquiry case type, challenge
- Model Availability Dashboard
- Introducing the Model Availability Dashboard
- Pega GenAI FAQ
- pegasystems/infinity-ai-agent-demonstrations, evaluation framework
- Building text analyzers
- Adding a text analyzer to a channel
- Defining topics for text analysis
- Editing conversation smart shapes
- Template operator for an IVA channel
- Digital Messaging connectors
- Chatbot escalations
If you have stood up an Agentic Messaging channel, I would be interested to hear how you handled two things: the Apply Data Transform layer governing which properties reach a prompt, and your regression approach for guardrails, since those are the two areas where I expect implementations to differ most.