# Learn how to bring your bots into the future on Customer Service 26.1 with Agentic Messaging

**URL:** <https://forums.pega.com/t/learn-how-to-bring-your-bots-into-the-future-on-customer-service-26-1-with-agentic-messaging/13239>\
**Category:** General\
**Tags:** self-service, pega-customer-service, conversational-channels, generative-ai\
**Created:** [August 21, 2026, 4:31pm UTC](https://forums.pega.com/t/learn-how-to-bring-your-bots-into-the-future-on-customer-service-26-1-with-agentic-messaging/13239 "2026-08-21T16:31:01Z")\
**Posts on this page:** 2\
**Page:** 1

<div class="post-metadata">

**Author:** ![FranklinMarkley](https://yyz2.discourse-cdn.com/pega/user_avatar/forums.pega.com/franklinmarkley/32/22890_2.png) [@FranklinMarkley](https://forums.pega.com/u/FranklinMarkley)\
**Post date:** [August 21, 2026, 4:31pm UTC](https://forums.pega.com/t/learn-how-to-bring-your-bots-into-the-future-on-customer-service-26-1-with-agentic-messaging/13239/1 "2026-08-21T16:31:01Z")

</div>

# 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](https://academy.pega.com/topic/introduction-agentic-messaging-voice-and-email/v2) 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](https://docs-previous.pega.com/decision-management/87/building-text-analyzers) 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`](https://docs-previous.pega.com/conversational-channels/87/adding-text-analyzer-iva) 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.

 ![image](https://pega1.discourse-cdn.com/pega/original/3X/8/c/8cb0d528cdeda21d6d1577125bff42278a07812e.png)

_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.

 ![image](https://pega1.discourse-cdn.com/pega/original/3X/7/3/73e75f65545e8400171e2d0fb143e8490ba0f9e7.png)

_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](https://docs-previous.pega.com/conversational-channels/87/editing-conversation-smart-shapes) 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.

 ![image](https://pega1.discourse-cdn.com/pega/original/3X/3/9/39d6f548b44d072cf5bbb60da4cab4416788731f.png)

_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](https://docs-previous.pega.com/pega-customer-service-implementation-guide/87/chatbot-escalations) fires. In App Studio under `Settings` then `Chat and messaging`, `Bot failure escalation` carries a `Consecutive non-matches` threshold that ships at 3.

 ![image](https://pega1.discourse-cdn.com/pega/original/3X/8/7/87c92d47b51d1210f44f59cc188f877ecd2b1116.png)

_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.

 ![image](https://pega1.discourse-cdn.com/pega/original/3X/8/4/84940c0d5e1d6c2b9a8324c99e0e440bb981932c.png)

_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

 ![image](https://pega1.discourse-cdn.com/pega/original/3X/4/c/4c202e49a2193473d12840108e73d6fa63bc148e.png)

_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.

 ![image](https://pega1.discourse-cdn.com/pega/original/3X/2/5/25784896db80c6429bfb782782a54338271787c4.png)

_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.

 ![image](https://pega1.discourse-cdn.com/pega/original/3X/b/0/b07596963967979aefe69cc02f4891092776f5e3.png)

_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.

 ![image](https://pega1.discourse-cdn.com/pega/original/3X/5/9/59a34162bd8aa56133095f6c30a76059c9fe7831.png)

_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](https://support.pega.com/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.

 ![image](https://pega1.discourse-cdn.com/pega/original/3X/6/7/679c3abe7fe18691be3daf35008dfdd6dfa4bf3b.png)

`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:

1. In Infinity Studio, go to `Channels`, open the channels landing page, and click `Create new channel`. Select `Agentic Messaging`.
2. On the `Overview` tab, set `Channel name` and `Channel description`. Under `Agent settings`, select your Agent from the `Agent` list.

 ![image](https://pega1.discourse-cdn.com/pega/original/3X/b/7/b711fd6bcdbd39f6ee70083d79a449bab04913f1.png)

_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.

 ![image](https://pega1.discourse-cdn.com/pega/original/3X/c/d/cd284c7e0588b34a501afe4733372e01668b81f2.png)

_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.

 ![image](https://pega1.discourse-cdn.com/pega/original/3X/2/f/2fa9e6cb57b08cd043311d95be40190be689c952.png)

_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.

 ![image](https://pega1.discourse-cdn.com/pega/original/3X/3/e/3e4ad26faa13a4297a4cd250223feeee485eee3f.png)

_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`.

 ![image](https://pega1.discourse-cdn.com/pega/original/3X/2/2/22d7f02297cb03f4fabc5bc345d8553a3b5e1680.png)

_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](https://academy.pega.com/challenge/configuring-self-service-agent-adding-fee-inquiry-case-type/v1) 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](https://github.com/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](https://academy.pega.com/topic/introduction-agentic-messaging-voice-and-email/v2)
- [Creating an agent for an Agentic Messaging interface](https://academy.pega.com/topic/creating-agent-agentic-messaging-interface/v2)
- [Setting up an Agentic Messaging interface and Web Messaging channel](https://academy.pega.com/topic/setting-agentic-messaging-interface-and-web-messaging-channel/v2)
- [Enhancing self-service AI experience with Agentic Messaging, module](https://academy.pega.com/module/enhancing-self-service-ai-experience-agentic-messaging/v2)
- [Configuring a self-service agent, adding a fee inquiry case type, challenge](https://academy.pega.com/challenge/configuring-self-service-agent-adding-fee-inquiry-case-type/v1)
- [Model Availability Dashboard](https://support.pega.com/model-availability-dashboard)
- [Introducing the Model Availability Dashboard](https://support.pega.com/support-doc/introducing-model-availability-dashboard)
- [Pega GenAI FAQ](https://support.pega.com/pega-genai-faq)
- [pegasystems/infinity-ai-agent-demonstrations, evaluation framework](https://github.com/pegasystems/infinity-ai-agent-demonstrations)
- [Building text analyzers](https://docs-previous.pega.com/decision-management/87/building-text-analyzers)
- [Adding a text analyzer to a channel](https://docs-previous.pega.com/conversational-channels/87/adding-text-analyzer-iva)
- [Defining topics for text analysis](https://docs-previous.pega.com/conversational-channels/87/defining-topics-text-analysis-iva)
- [Editing conversation smart shapes](https://docs-previous.pega.com/conversational-channels/87/editing-conversation-smart-shapes)
- [Template operator for an IVA channel](https://docs-previous.pega.com/conversational-channels/86/template-operator-iva-channel)
- [Digital Messaging connectors](https://docs-previous.pega.com/pega-customer-service-implementation-guide/87/digital-messaging)
- [Chatbot escalations](https://docs-previous.pega.com/pega-customer-service-implementation-guide/87/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.

---

<div class="post-metadata">

**Author:** ![Kamalesh\_mohanty](https://avatars.discourse-cdn.com/v4/letter/k/ecb155/32.png) [@Kamalesh\_mohanty](https://forums.pega.com/u/Kamalesh_mohanty)\
**Post date:** [September 12, 2026, 6:13pm UTC](https://forums.pega.com/t/learn-how-to-bring-your-bots-into-the-future-on-customer-service-26-1-with-agentic-messaging/13239/2 "2026-09-12T18:13:13Z")

</div>

Great article,is there an option to acheive this in Pega 25.1.2 CS version? @FranklinMarkley