In Part 2 of this series, we reviewed the various elements that make up a custom agent in Copilot Studio and learned how they work together to create intelligent, task-oriented conversations that can automate complex workflows.
Now in Part 3, we’re shifting gears towards practical application. Today, we'll be diving into some real-world use cases and showing how Copilot Studio can be used to build SAP agents that transform user experiences. We’ll walk through some specific scenarios that highlight how these agents can simplify business processes, save time, and even breathe new life into those old-school SAP workflows we all know and love (or...tolerate).
Conversational Agent Scenarios
First up, we’ll take a look at a couple of conversational agent scenarios to illustrate how Copilot Studio can be used to support SAP process flows. These examples are based on everyday business processes like checking order statuses or submitting service requests. The goal is to show how conversational agents can help streamline routine tasks by guiding users through workflows, providing timely information, and making it easier to interact with SAP systems.
Self-Service Agents
One of the most obvious (but still incredibly useful) use cases for conversational agents is to create self-service agent experiences. These types of agents can be general-purpose—supporting a broad set of users across the organization—or more specialized, tailored to the needs of a specific department or team (e.g., finance or procurement).
Since most users are familiar with the concept of HR self-services, we’ll start by introducing an HR self-service agent connected to SAP HCM and/or SAP SuccessFactors. This type of agent can help employees with routine tasks like checking leave balances, updating personal details, answering policy questions, or starting a time-off request—all through a simple, conversational interface.
HR Task Automation
Figure 1 below illustrates what this kind of HR self-service agent experience could look like if we were to deploy our agent to Microsoft Teams. Here, we can configure topics such as Personal Details, Leave Requests, or Expenses to guide employees through various self-service functions.
Figure 1: Interacting with an HR Self Service Agent - Part 1
As we noted in Part 2, the user interface doesn't have to be limited to just a basic text interface. For example, if the user wants to process a leave request, we can present a simplified form requesting key details using Adaptive Cards technology as shown in Figure 2 below. From a design perspective, there are a couple of interesting things going on here:
The user doesn't have to navigate from the agent to go log into SAP to fill in the form - it's seamlessly woven into the conversation flow.
The form has been simplified down to the bare essentials. Since Copilot Studio agents integrate seamlessly with Teams and Entra ID, we already know contextually who the employee is. So, we don't need them to re-enter their employee ID (or PERNR for you SAP HR heads), etc.
Figure 2: Interacting with an HR Self Service Agent - Part 2
Advanced Task Automation
Whether we choose to deploy our agent in something like Teams or as part of a web/mobile app, we can take advantage of its responsive design to level up the user experience. For example, Figure 3 illustrates what our agent looks like running on the Teams mobile app. Here, we can use the device camera (or camera roll) to enable employees to upload expense receipts directly from within the agent experience.
Figure 3: Uploading Expense Receipts via a Smart Phone
From here, we can take advantage of Copilot Studio's integration with Power Automate to call out to an AI model developed using AI Builder (or some other AI model source) to analyze the contents of the receipt. Then, armed with the information gleaned via computer vision (i.e., OCR), we can use SAP and/or HTTP connectors to post the expense transaction to SAP. For good measure, we can also upload the receipt file to SAP while we're at it. Figure 4 illustrates how the entire task flow comes together inside of Copilot Studio.
Figure 4: Streamlining Expense Receipt Processing in a Conversational Agent
Adding Knowledge Resources
Once we get started building out topic conversation flows that integrate with SAP, we can probably come up a lot more interesting task flows to automate. While these additions can make our agents more impactful, it's also important to remember that Copilot Studio has more to offer than task automation.
From a usability perspective, we can round out the user experience of our HR self-service agent by adding in knowledge sources (see Figure 5). Specific knowledge resources might include the employee handbook, HR policy guides, or instruction guides which walk employees through how certain HR-related processes work. These additions enable our agent to utilize generative AI to answer policy questions and better understand where an employee is within a given process flow.
Figure 5: Adding Knowledge Sources to our HR Self-Service Agent
Customer Support with AI-Powered Knowledge Search
Another powerful use case for Copilot Studio is in the customer service space—specifically, helping agents (or even customers themselves in a portal experience) get quick answers to complex questions by tapping into an enterprise knowledge base.
When it comes to knowledge sources, it’s important to remember that Copilot Studio supports a wide range of knowledge sources and connectors. Add in a little pro code magic, and these tools unlock the ability to surface data and business logic from your SAP systems. And we're not just talking structured data from the SAP system database. We can also get our hands on unstructured data from log files or attachments sitting in an SAP content repository such as the SAP Document Management Service (SAP DMS).
With that in mind, let's look at what it takes to build a support agent that can use an SAP-based knowledge base to answer detailed, domain-specific questions using natural language.
Defining a Knowledge Source
Most of the demos you see on Copilot Studio knowledge sources focus on SharePoint repositories. While SharePoint could be an option for this use case, the reality for most SAP customers is that their attachments normally live elsewhere and there's probably not an appetite to migrate/duplicate the contents of a live repository. In these situations, we can use Azure AI Search to build a bridge.
To illustrate this concept, check out Figure 6 below. Here, we have a pretty typical SAP system setup where attachments uploaded to SAP DMS are physically stored in an OpenText repository. Instead of migrating the attachments to a different repository, we can utilize the OpenText data source in Azure AI Search to create a search index directly on the attachment content. We can then enrich that index with metadata from SAP (e.g., document attributes, characteristic assignments, etc.) to reconstruct the document taxonomy. Finally, we can plug in that search index into Copilot Studio as a knowledge source and we're in business.
Figure 6: Surfacing SAP Attachment Data via Azure AI Search Indexes
While an integration scenario like the one shown in Figure 6 definitely requires some pro-code expertise, the experience within Copilot Studio remains consistent. In other words, a knowledge source is a knowledge source—regardless of how it’s connected. There's no need to (re)train the agent on the material; once it's linked, the content is available for generating intelligent, contextual responses.
Providing Generative Answers to Questions
As soon as our knowledge source(s) are in place, we can utilize the Create generative answers task shown in Figure 7 below to let the built-in generative AI models in Copilot Studio scan through our SAP knowledge base and respond to natural language queries.
Figure 7: Adding Support for Generative Answers in the Conversation Flow
Alternatively, we can utilize AI Prompts in AI Builder to produce generative answers in a more dynamic fashion. While this approach does add a bit to the licensing cost due to the utilization of AI Builder, it does offer a distinct advantage: it allows us to do some light prompt engineering.
As you can see in Figure 8 below, we can provide the prompt/mini-agent with some context in terms of approach, tone, and so forth. We can also specify how the prompt should respond. Here, for example, we might instruct the prompt to format/structure its response into some kind of adaptive card schema.
Figure 8: Building a Custom AI Prompt in AI Builder
After our AI Prompt is built, we can weave it into a Power Automate cloud flow which we can then call from our custom agent in Copilot Studio as shown in Figure 9 below.
Figure 9: Integrating our AI Prompt into a Power Automate Cloud Flow
Putting it All Together
Once we've integrated our knowledge base into our customer service agent and configured support for generative answers, we can round out the design with the same kind of task flow/actions we put together for our HR self-service agent. Some example actions could include the following:
Lookup my (or a customer's) open service requests
Create a new service request
Cancel an existing service request
Schedule an appointment (perhaps outside of SAP)
Register for alerts/notifications when crews are dispatched, etc.
Autonomous Agent Scenarios
So far, we’ve focused on conversational agents—tools that help users navigate processes and access information through guided, natural language interactions.
In this section, we’ll shift gears and explore how Copilot Studio can also be used to build autonomous agents—agents that proactively work behind the scenes, making decisions and handling complex workflows on their own. While some of these features are still in preview, you'll see how these types of agents go beyond traditional workflow automation by incorporating reasoning, memory, and dynamic data access to operate more like digital coworkers than scripted bots.
More specifically, we’ll look at scenarios where autonomous agents can monitor business events, trigger SAP transactions, and even coordinate follow-up actions across systems—without constant human input. It's a big leap from rules-based automation, and it's one of the most exciting frontiers in Copilot Studio.
From Topics to Event Triggers
As we've seen throughout this series, conversational agents in Copilot Studio are primarily activated based on trigger words defined in various topics. However, since autonomous agents work offline, they require a different kind of trigger: event triggers.
If you're familiar with how triggers work in Power Automate, you'll find that event triggers in Copilot Studio follow a similar pattern. However, there are some important differences. The video below offers a clear overview and breakdown of these new features.
Whenever we build a new autonomous agent, the first step is to turn on generative orchestration switch shown in Figure 10 below. This setting unlocks access to event triggers. Here, it's worth noting that while it is possible to disable this setting later on, it can wreak havoc on your existing topics. For this reason, and others, we strongly recommend that you keep your conversational and autonomous agents separate.
Figure 10: Turning on Generative Orchestration for a Custom Agent
Once this setting is turned on, we can begin adding all kinds of event triggers to our autonomous agent. As you can see in Figure 11 below, we can tap into Microsoft's huge collection of connectors to define the relevant event triggers. Some notable event trigger examples include:
At a recurring time interval (e.g., every night at midnight)
Whenever an email arrives to an individual or shared inbox
Whenever a record is added to a SharePoint list or database table
Whenever a file gets uploaded to OneDrive, SharePoint, or Azure
Whenever a task gets assigned in some kind of planning or scheduling tool
Figure 11: Adding an Event Trigger to an Autonomous Agent
Understanding How Autonomous Agents Are Built
Unlike conversational agents where the topic/conversation flow follows a familiar imperative programming style, autonomous agents utilize a more declarative approach. To understand how the approach with autonomous agents differs, check out the video below.
As you observed in the video, autonomous agents are primarily built using two key components: event triggers and actions. Event triggers not only initiate the agent’s behavior but also supply the necessary input data to get things rolling. From there, it’s the actions that take over—executing logic, invoking external services, and driving outcomes. In essence, actions are the workhorses of autonomous agents, performing all the heavy lifting behind the scenes.
Figure 12 illustrates all the various options Copilot Studio provides for building actions. Besides the various actions included in the 1,400+ standard connectors, we can incorporate custom Power Automate cloud flows, prompts from AI Builder, custom connectors, and even AI skills developed using Azure AI Foundry.
Figure 12: Adding Actions to an Autonomous Agent
While the built-in generative AI in Copilot Studio ultimately calls the shots for how autonomous agents work at runtime, we can do a lot to influence its thought process by writing out detailed instructions in the Instructions section highlighted in Figure 13 below. You can think of these instructions as being kind of like pseudocode in the sense that you're providing detailed, step-by-step instructions for how to solve a particular set of problems.
Figure 13: Defining Instructions for Autonomous Agents
We don't have to get overly technical when filling out the instructions section. Indeed, if we've done our job right and followed good development practices, our action definitions will be pretty self-explanatory and we just need to guide the agent to selecting the right action for the right job. The more detail we provide here, the better the results will be.
Here, it's helpful to think of actions in terms of appliances you use every day like a coffee machine. You don’t need to know how the coffee machine heats up the water or builds pressure; you just push a button and get coffee. The messy details are hidden inside (or encapsulated), and all you see is the simple interface. Our action definitions should have this same level of simplicity and be documented withe same level of intuitiveness so that the generative AI can understand what they're for, what they do, and how to communicate with them.
Gen AI-Powered Inbox Assistants
Now that we have the basics of autonomous agents out of the way, let's turn our attention towards another real-world example from the customer service domain. This time, we want to build an autonomous agent that can respond to various types of service requests that are sent to a shared inbox such as support@acme.com. Figure 14 illustrates the basic process flow.
Figure 14: Autonomous Email Agent Concept
To put something like this together, we first need to define an event trigger to listen for the arrival of incoming support requests. The "When a new email arrives in a shared mailbox" trigger for the standard Outlook connector does the trick for this (see Figure 15 below). From here, you can define filters based on sender domains, and so forth.
Figure 25: Defining an Event Trigger Using the Outlook Connector
Next, we need to build some actions to analyze the contents of the incoming email request, extract useful information, and ultimately process the request. While the specific implementation details of these three tasks is beyond the scope of this blog series, we're basically talking about building a few Power Automate cloud flows.
Unlike normal Power Automate cloud flows though, we will need to leverage tools like AI Builder so that we can leverage features like entity extraction and generative AI-based text analysis to analyze and extract details about the nature of the customer's request. We explored how to accomplish some of these tasks previously in our blog on SAP and AI Builder.
At the end of the day, since we're talking about unstructured data in the body of an email, this process can get tricky and isn't 100% foolproof. However, with the tools included in Copilot Studio and the Power Platform, all this is way easier than you might think. And of course, with Power Automate, we can always add logic to re-route/escalate questionable requests to a human agent for verification.
Closing Thoughts
These are truly exciting times for those of us at the intersection of SAP and Microsoft’s AI ecosystem. Over the past few months, we’ve explored how Copilot Studio is reshaping the way we think about enterprise UX—from reducing friction in everyday workflows to creating conversational experiences that feel less like traditional software and more like natural collaboration.
What’s especially impressive is just how far Microsoft has come with Copilot Studio in such a short amount of time. In roughly 18 months, we've gone from concept to a robust platform that’s already delivering meaningful value across a wide range of industries—including those running SAP. And the momentum is only picking up from here.
To keep the energy going, we’re putting together a new webinar series where we’ll demo these concepts live and walk through real-world examples that bring everything we’ve covered to life. Whether you're just getting started or looking to push the boundaries of what's possible, you won’t want to miss it.
And don’t worry—we’re not done yet. With a wave of new features just around the corner, we’ll continue to share deep dives, tips, and hands-on guidance right here. So stay tuned to this space as we continue to explore what’s next in this fast-moving, AI-powered world.
