Experience the future of customer service with AI agents (Public Preview of Autonomous AI Agents for Dynamics 365 Customer Service and Contact Center).

Real-time User Journey

This feature enables a seamless, autonomous end-to-end journey for both customers and service representatives:

1. Intent Detection: A customer reaches out via chat or voice. The Customer Intent Agent uses generative AI to immediately analyze the request against an “intent library” to understand exactly what the customer needs.
2. Autonomous Resolution or Routing: For common issues, the agent provides tailored solutions or asks follow-up questions to resolve the issue without human intervention.
3. Case Automation: If a human representative is needed, the Case Management Agent automatically creates a case, pre-filling attributes (like issue description and contact info) so the representative has full context immediately.
4. Proactive Follow-up: If the case remains open, the Case Management Agent tracks it and sends automated follow-up emails. Once resolved, it can even close the case and populate resolution details autonomously.
5. Knowledge Capture: After the interaction, the Customer Knowledge Management Agent analyzes the conversation and case notes to draft a new knowledge article, ensuring the organization’s expertise grows automatically.

Step-by-Step: How to Enable This Feature

To enable these agents during the public preview, follow these steps:

Prerequisite: Ensure you have Microsoft Copilot Studio message capacity set up in the Power Platform Admin Center (PPAC).

• Step 1: Access the Admin Center Sign in to the Copilot Service admin center (or Dynamics 365 Customer Service admin center).
• Step 2: Enable the Intent Agent Go to Support experience > Intent. Setup “Intent Discovery” to let the AI analyze historical case and conversation data. Once intents are generated, review and Approve them to move them to your library.
• Step 3: Setup Case Management Agent Go to Case Settings > Case Management Agent.
  • Select Manage to configure “Case creation and update” rules.
  • Select Autonomous case follow-up and closure to set rules for how many follow-ups the AI should send before closing a case.
• Step 4: Configure Knowledge Management Agent Go to Support experience > Knowledge > Customer Knowledge Management Agent.
  • Select Setup connections to link to Dataverse.
  • Enable the Power Automate flows provided in the setup wizard.
  • Click Publish to make the agent active in Copilot Studio.

Step 5: Assign Experience Profiles Go to Workspaces > Agent experience profiles. Edit the profile for your representatives and toggle on Copilot AI features (like intent-based suggestions and case processing) to “Enabled.”

Ref – https://learn.microsoft.com/en-us/dynamics365/contact-center/administer/autonomous-agents-overview

Experience the future of customer service with AI agents

Introduction

The Saga pattern is a design pattern used to manage distributed transactions in a microservices architecture. It offers a way to handle long-running transactions and ensure data consistency across multiple services without relying on a traditional two-phase commit protocol. This pattern is particularly useful in systems where transactions span multiple services and a failure in one service should not leave the system in an inconsistent state.

Understanding the Saga Pattern

The Saga pattern breaks down a large transaction into a series of smaller, independent sub-transactions, each of which can be managed and executed independently. Each sub-transaction has a corresponding compensating transaction that undoes its effects if the sub-transaction fails. These compensating transactions are essential for maintaining consistency and rolling back changes if necessary.

Key Concepts

• Sub-transaction: A smaller transaction that is part of the overall saga.
• Compensating transaction: An operation that reverses the effects of a sub-transaction in case of failure.
• Saga orchestrator: A service or component responsible for managing the execution and coordination of the sub-transactions and their compensating transactions.
• Saga participant: A service that executes a sub-transaction and its compensating transaction.

Types of Sagas

There are two main types of sagas: choreography-based and orchestration-based.

Choreography-Based Saga

In a choreography-based saga, each service involved in the transaction knows what to do next and notifies the next service when its part of the transaction is complete. This approach is decentralized and allows services to interact through events, reducing the need for a central coordinator.

Orchestration-Based Saga

In an orchestration-based saga, a central orchestrator manages the entire transaction, directing each service to perform its part of the transaction and, if necessary, its compensating transaction. This approach provides more control and visibility but introduces a single point of failure.

Implementing the Saga Pattern

Implementing the Saga pattern involves several steps:

1. Define the Sub-Transactions and Compensating Transactions

Identify the individual steps of the overall transaction and determine what compensating actions are necessary if any step fails.

2. Choose the Saga Type

Decide whether a choreography-based or orchestration-based approach is more suitable for your use case.

3. Implement the Saga Orchestrator (if applicable)

If using an orchestration-based saga, develop the orchestrator to manage and coordinate the sub-transactions.

4. Implement the Sub-Transactions and Compensating Transactions

Develop the services to execute the sub-transactions and their corresponding compensating transactions.

5. Test and Validate

Thoroughly test the saga to ensure that it handles failures correctly and maintains data consistency.

Advantages and Challenges

Advantages

• Resilience: The Saga pattern enhances the resilience of a system by ensuring that failures in one service do not leave the system in an inconsistent state.
• Scalability: By breaking down a large transaction into smaller sub-transactions, the Saga pattern can improve the scalability of a system.
• Flexibility: The pattern allows for more flexible transaction management, as each sub-transaction can be managed independently.

Challenges

• Complexity: Implementing the Saga pattern can add complexity to the system, as it requires careful design and coordination of sub-transactions and compensating transactions.
• State Management: Keeping track of the state of each sub-transaction and its compensating transaction can be challenging, especially in a choreography-based saga.
• Consistency: Ensuring data consistency across multiple services can be difficult, particularly in the face of network failures and other issues.

Use Cases

The Saga pattern is particularly useful in the following scenarios:

1. E-commerce

Managing orders that involve multiple services, such as inventory, payment, and shipping.

2. Travel Booking

Handling reservations that span multiple services, such as flights, hotels, and car rentals.

3. Banking

Processing transactions that involve multiple accounts and services, such as transfers and loans.

Conclusion

The Saga pattern is a powerful tool for managing distributed transactions in a microservices architecture. By breaking down a large transaction into smaller sub-transactions and providing compensating transactions, the pattern ensures data consistency and system resilience. While implementing the Saga pattern can be complex, the benefits it offers in terms of scalability, flexibility, and fault tolerance make it a valuable addition to any distributed system.