The Microsoft Copilot Studio is revolutionizing the design and construction of conversational agents. Normally, developers-built agents around Topics, which are essentially conversational flows invoked by specific phrases. Topics worked well for structured chatbot scenarios, but they became more and more difficult to manage as agents became more complex.

Microsoft has introduced Skills as a core building block for modern agent development with the rise of AI-powered agents. This represents a shift from static conversation trees to intelligent agents that can reason, choose the appropriate capability, and dynamically complete tasks. The developers are now building reusable business capabilities that an AI agent can call on when needed, instead of building big sets of conversational flows.

Image 1: Agent architecture showing Instructions, Knowledge, Skills, Tools, and Workflows.

Key Takeaways

• Copilot Studio agents are shifting from Topics (trigger-phrase conversation flows) to Skills (reusable business capabilities the agent invokes through reasoning).
• Topics work for simple, structured chatbots but get hard to maintain as agents scale to dozens or hundreds of conversation paths.
• Skills let an agent decide what to do based on user intent, not just which phrase matched.
• Skills are reusable across multiple agents (Sales, Service, HR), reducing duplicated logic.
• For Dynamics 365 and Power Platform developers, Skills feel closer to Custom APIs, Actions, Plugins and Power Automate Flows than to chatbot design.
• This shift reflects Microsoft’s broader move from chatbot development to enterprise AI agent development.

Understanding the Traditional Topic-Based Approach

The topics were mostly designed for chatbot experiences. Each topic represented a predefined conversation path, triggered by certain user phrases. A typical topic might have a structure such as: User requests a password reset.

→ Request Employee ID

→ User Validation

→ Change Password

→ Confirm Completion

Topics worked well in simple situations. However, as organizations added more use cases, agents tended to have dozens or even hundreds of Topics, making maintenance more and more difficult.

Topics presented common challenges such as:

• Handling multiple trigger phrases
• Complex conversation tree maintenance
• Dealing with unanticipated requests from users
• Reuse of functionality between multiple agents
• Scaling agents as the business grows

Image 2: Topic showing trigger phrases, conditions, and conversation nodes.

Topics vs Skills: A Comparison

The introduction of Skills changes how developers think about agent development.

Topics guide a user through a predetermined conversation.

Skills are for the execution of a business task.

This distinction is important because modern AI agents are expected to understand intent, not just match trigger phrases.

Image 3: Showing a skill record in a Copilot Agent.

Why Skills?

The move to Skills is part of Microsoft’s broader vision of an AI agent.

Rather than asking:

Which topic should this request go to?

Now the agent asks:

What skill can be used to solve this problem?

This feature enables agents to make intelligent decisions based on the user’s intent.

Let us consider there’s an IT help desk agent.

A user wrote:

My VPN is not working. If you can’t fix it, open a support ticket.

Often, in a topic-based system, this scenario would require multiple Topics and careful routing logic.

However, with skills, the agent can:

1. Search the knowledge base.
2. Run a VPN troubleshooting skill.
3. Verify that the problem is solved.
4. If necessary, invoke the create ticket skill.

While the user experiences a smooth interaction, the agent manages various functions in the background.

Benefits of Skills

1. Better Reusability

Skills are versatile and modular; they can be shared across multiple agents.

For example:

• Create Ticket Skill
• Check Ticket Status Skill
• Password Reset Skill
• User Onboarding Skill

Instead of recreating these capabilities in every agent, they can be reused wherever needed.

2. Improved Scalability

As business requirements grow, adding new capabilities becomes easier.

Rather than maintaining dozens of Topics and conversation nodes, developers need to add new Skills.

3. AI-Driven Decision Making

The agent uses the skills to reason about the request and decide on the best action. As a result, the conversations become more natural and flexible.

4. Easier Maintenance

Each skill is concerned with one responsibility only.

When it is necessary to make changes, the developers update the appropriate Skill without affecting the functionality that is not related.

5. Alignment with Software Development Practices

For developers working with Dynamics 365 and the Power Platform, Skills are quite familiar.

They share a similar foundation with things like Custom APIs, Actions, Plugins, and Power Automate Flows.

Instead of getting into the nitty-gritty of designing conversation trees, developers can focus on implementing real business solutions that make a difference.

6. Better Multi-Agent Architecture

Organizations are progressively implementing specialized agents. A Sales Agent, Service Agent, and HR Agent can all utilize shared Skills without repeating logic.

Real-World Example: IT Help Desk Agent

Topic-Based Design

Topic: Password Reset

Topic: VPN Access

Topic: Software Installation

Topic: User Onboarding

Topic: Ticket Creation

Topic: Ticket Status

Every Topic requires:

• Trigger phrases
• Variables
• Conditions
• Conversation logic

As the number of Topics increases, management becomes more complex.

Skill-Based Design

Knowledge Source

├── Password Reset Skill

├── VPN Troubleshooting Skill

├── User Onboarding Skill

├── Create Ticket Skill

└── Check Ticket Status Skill

The agent determines which Skill to invoke based on the user’s intent, creating a more intelligent and maintainable solution.

Image 4: Complete Copilot Studio agent showing Instructions, Knowledge, Skills, and Actions.

Conclusion

The transition from Topics to Skills represents more than a feature change, it reflects Microsoft’s broader shift from chatbot development to AI agent development.

Topics were designed for structured conversations and predefined paths. Skills are designed for intelligent agents that can reason, dynamically select capabilities, and solve problems more effectively.

For Dynamics 365 CRM and Power Platform professionals, Skills introduce a development model that feels closer to building business services than designing chatbot conversations. They promote reusability, scalability, easier maintenance, and AI-driven orchestration.

As Copilot Studio continues to develop, Skills are becoming the foundation for building modern, enterprise-grade AI agents. Organizations adopting this approach today will be better positioned in the future to create flexible, scalable, and intelligent solutions for the future.

FAQs

What is the difference between Topics and Skills in Copilot Studio?

Topics are predefined conversation flows triggered by specific phrases. Skills are reusable business capabilities that an AI agent selects dynamically based on user intent.

Why is Microsoft moving from Topics to Skills in Copilot Studio?

Topic-based agents become difficult to maintain as the number of conversation flows grows. Skills let agents reason about a request and choose the right capability, making them easier to scale and maintain.

Can Skills be reused across multiple Copilot Studio agents?

Yes. A Skill such as Create Ticket or Password Reset can be shared across a Sales Agent, Service Agent or HR Agent without rebuilding the logic each time.

Are Skills related to Power Platform components like Custom APIs or Power Automate Flows?

Yes. Skills share a similar foundation with Custom APIs, Actions, Plugins and Power Automate Flows, making them familiar to Dynamics 365 and Power Platform developers.

Do Skills replace Topics completely in Copilot Studio?

Not necessarily. Topics can still suit simple, structured scenarios, but Skills are Microsoft’s direction for building intelligent, scalable AI agents.

The post From Topics to Skills: The Evolution of Copilot Studio Agents first appeared on Microsoft Dynamics 365 CRM Tips and Tricks.

Modern Dynamics 365 applications often require intelligent automation to reduce manual effort and improve customer experience. Agent Nodes in Copilot Studio Agent Flows allow an existing AI agent to be invoked as part of a workflow. The flow can pass information to the agent, receive a structured response, and use that response in subsequent actions. In this example, a customer support email is analyzed by an agent, and the result is used to create a Dynamics 365 Case.

Key Takeaways

• Add an AI agent to Copilot Studio Agent Flows using the Run an agent
• Pass dynamic email subject and body to the agent at runtime.
• Use Text + JSON to return structured AI outputs.
• Automatically classify customer emails by category and priority.
• Use AI-generated results to create Dynamics 365 Cases.
• Replace manual triggers with automated email or business-event triggers in production.

Business Scenario

A customer support team receives requests that need to be classified before a Case is created. The requirement is to automatically analyze the incoming request and determine the appropriate routing information.

• Identify the case category, such as Billing, Technical, Sales, or General.
• Determine the priority: Low, Medium, High, or Critical.
• Generate a short summary of the customer’s issue.
• Use the AI-generated information while creating a Dynamics 365 Case.

Step 1: Create an Agent Flow

Navigate to: Copilot Studio → Flows → New Flow

Choose the Manually trigger a flow trigger.

Create the following trigger inputs:

Input Type (Text) – Email Subject (emailSubject), Email Body (emailBody)

This trigger is used only for demonstration purposes. In production, these values can come directly from Outlook, Dynamics 365, or another connector.

Step 2: Add the Agent Node

Click the + icon below the trigger and select: Run an agent

If prompted, sign in using your Microsoft account.

Select your published agent from the Agent dropdown.

Note: If the agent is not visible, verify that it has been published. Unpublished agents are not listed in the dropdown.

Step 3: Configure the Runtime Message

The Message field is the runtime input sent to the agent. Insert the trigger’s emailSubject and emailBody using dynamic content; do not hardcode the values in the flow.

Example message:
Analyze the following customer support email and identify the information required for case routing in Dynamics 365.

Email Subject:
[dynamic emailSubject]
Email Body:
[dynamic emailBody]
Based on the email, determine:
– Category (Billing, Technical, Sales, or General)
– Priority (Low, Medium, High, or Critical)
– A concise one-line summary of the issue.

Return the response using the JSON schema provided. Do not include any additional text, explanations, or markdown.

Step 4: Configure the Agent Response

Under Agent response as shown in the above screenshot, select Text + JSON. In the JSON section, define the expected structure so the flow can use each result as a separate output.

{
 “type”: “object”,
 “properties”: {
 “category”: { “type”: “string” },
 “priority”: { “type”: “string” },
 “summary”: { “type”: “string” }
 },
 “required”: [“category”, “priority”, “summary”],
 “additionalProperties”: false
}

This produces structured outputs such as category, priority, and summary that can be selected as dynamic content in later actions.

Step 5: Test the Agent

To test the Agent Flow, use a real customer email as the input for the manual trigger.

1. Run the flow using the Test
2. In the Email Subject field, enter the subject of a received customer email.
3. In the Email Body field, copy and paste the corresponding content of the email.
4. Execute the flow.

The email subject and body are passed dynamically to the Run an agent node. The agent analyzes the provided content according to its configured instructions and JSON schema.

After the flow completes, review the Run history to see the Agent Node’s response. The structured output will contain the properties configured in the response schema, such as:

{
  “category”: “Billing”,
  “priority”: “High”,
  “summary”: “Customer reports being charged twice for an invoice and requests investigation and refund.”
}

The actual values will vary depending on the email used for testing. These structured outputs can then be used by subsequent actions in the flow, such as creating or updating a Dynamics 365 Case.

Note: The manual trigger is used here only to simulate the receipt of a customer email. In a production implementation, the trigger can be replaced with an appropriate automated trigger so that the email content is passed to the Agent Node without requiring manual input.

Step 6: Use the Agent Output in Dynamics 365

The structured output from the Agent Node can now be used in a Dataverse action such as Add a new row to create a Case.

In this implementation:

• Title was mapped to the AI-generated Summary.
• Description was mapped to the Email Body.
• Customer was mapped by binding an existing Account through its OData ID.

Note: The Customer field on the Case table is a lookup field. It requires a valid Account or Contact reference (OData ID). Providing only the account name will result in an error.

Result

After running the flow successfully:

• The customer email was analyzed by the AI agent.
• The issue was classified automatically.
• Priority and summary were generated.
• A Dynamics 365 Case was created using the structured output returned by the agent.

This demonstrates how an Agent Node can intelligently process business data before it is consumed by Dynamics 365.

Conclusion

The Run an agent node makes it easy to integrate AI into Dynamics 365 workflows. By passing real-time data to an agent and using its structured output, tasks such as email analysis, case classification, and case creation can be automated efficiently.

FAQs

1. What is an Agent Node in Microsoft Copilot Studio?

An Agent Node, available through the Run an agent action in Copilot Studio Agent Flows, allows a workflow to invoke a published AI agent. The flow can pass dynamic information to the agent, receive a structured response, and use that output in subsequent actions such as creating a Dynamics 365 Case.

2. How do I add an Agent Node to an Agent Flow in Copilot Studio?

Create an Agent Flow in Copilot Studio, add a trigger, and select Run an agent from the available actions. Choose the required published agent, configure the runtime message, and define the expected response format. The agent can then process information passed from the flow.

The post How to Add an Agent Node to an Agent Flow in Microsoft Copilot Studio first appeared on Microsoft Dynamics 365 CRM Tips and Tricks.

Business documents such as purchase orders, invoices, reports, and shipping documents often contain valuable information in tabular format. In many organizations, this information is still copied manually into spreadsheets or business applications, which takes time and increases the possibility of errors.

Microsoft Copilot Studio includes Computer Use, a capability that enables an agent to interact with applications through their user interface. Instead of depending on APIs or custom integrations, the agent can automatically open applications, navigate through screens, identify information, and complete tasks based on what it sees on the screen.

In this blog, we’ll build a practical solution that uses Computer Use to open a PDF document, identify the primary table, and extract its contents into a structured JSON format. The extracted data is then passed to a Power Automate flow, which converts it into a CSV file and sends it as an email attachment. This demonstrates how AI-driven UI automation can simplify document processing while reducing manual effort.

Let’s consider a potential use case:

Many organizations store business documents such as purchase orders, invoices, and reports in SharePoint document libraries for centralized access and collaboration. These documents often contain important tabular information that needs to be extracted and shared with other teams or business applications. Performing this task manually requires users to open each PDF, identify the required table, and copy the data into a structured format, making the process repetitive and prone to errors.

In this scenario, a purchase order PDF is stored in a SharePoint document library. A Copilot Studio agent uses Computer Use to open the PDF directly from SharePoint, identify the primary table containing the line-item details, and extract the data into a structured JSON format. The extracted data is then passed to a Power Automate flow, which converts it into a CSV file and sends it as an email attachment. This approach reduces manual effort and provides a simple way to automate document processing using AI-driven UI automation.

What You’ll Learn

By the end of this article, you’ll know how to:

• Configure a Computer Use tool in Microsoft Copilot Studio.
• Extract tabular data from a PDF stored in SharePoint.
• Pass the extracted JSON to Power Automate.
• Generate a CSV file from the extracted data.
• Email the CSV file automatically using Outlook.

Let’s go through the end-to-end implementation of this solution.

Prerequisites:

Before we get started, ensure you have the following:

• A Microsoft Copilot Studio environment with Computer Use enabled.
• A Microsoft 365 tenant with SharePoint Online available.
• A SharePoint document library containing the PDF document to be processed.
• A Power Automate environment to create the flow that converts the extracted JSON into a CSV file and sends it via email.
• An Outlook connection configured in Power Automate to send emails.
• A sample PDF containing tabular data (for this blog, a Purchase Order PDF is used).

Step 1:

Sign in to Microsoft Copilot Studio by navigating to https://copilotstudio.microsoft.com/. Once you’re signed in, open your agent and select Tools from the left navigation menu. Click Add tool, select New tool, and then choose Computer use to create a new Computer Use tool.

Step 2:

Click Add and configure to create the Computer Use tool. This opens the configuration page where you can define the execution environment, authentication settings, and instructions for the agent. For now, keep the default configuration, as we will add the instructions for the Computer Use agent in a later step.

Step 3:

The Computer Use tool configuration page will open. Enter an appropriate Name and Description for the tool. Under the Model section, select Claude Sonnet 4.5, as it provides the capabilities required for performing Computer Use tasks. Once the basic configuration is complete, click Save to proceed.

Step 4: Add the Computer Use Instructions
The next step is to provide instructions that guide the Computer Use tool on how to interact with the PDF. These instructions tell the agent where the PDF is located, how to handle authentication, identify the required table, and return the extracted data in a structured JSON format.

Copy and paste the following instructions into the Instructions section of the Computer Use tool.

You are an intelligent document extraction assistant.
Your task is to extract the primary tabular data from a PDF document.
Open Microsoft Edge.
Navigate to: Please paste the sharepoint document folder link
If authentication is required:
– Use the stored username.
– Use the stored password.
– If Multi-Factor Authentication (MFA) is requested, pause and wait for the user to approve it.
– Continue automatically after authentication succeeds.

Wait until the PDF is fully loaded.
Examine the document to identify the main table containing business data.
Ignore logos, headers, addresses, titles, summaries, footers, and terms & conditions.
Focus on the largest table containing rows of business records or line items.
If the table spans multiple pages:
– Scroll through the document.
– Continue extracting rows until the complete table has been captured.
– Do not stop after the first page.

Preserve the original column names from the table header.
Extract every row exactly as displayed.
Use the following data types consistently:
– Line: String
– Qty: String
– Item Code: String
– Description: String
– UOM: String
– Unit Price: String
– Amount: String

Return ONLY a valid JSON array.
Each JSON object should represent one row.
Use the actual column names from the PDF as the JSON property names.
Do not include explanations, markdown, summaries, or additional text.
Return only valid JSON.

Step 5: Configure the Execution Settings
Next, configure the execution settings for the Computer Use tool. Set the Outputs type to Text, as the agent will return the extracted table data in JSON format. Under Machine, select Hosted Browser to execute the automation in a Microsoft-hosted browser session. Finally, set Credentials to use to End user credentials so the agent can authenticate using the credentials configured for the end user.

Step 6:
Under Human supervision, assign a reviewer who can receive and respond to requests from the Computer Use agent. Human supervision allows the agent to contact a designated reviewer for confirmation or to request additional information whenever manual intervention is required during execution. These notifications are sent through Outlook. Set the Response time limit to 1 Hour.

Next, under Stored credentials, click Add and configure the credentials that the agent will use to sign in to the SharePoint site. Store the username and password for the Microsoft sign-in page (for example, login.microsoftonline.com). During execution, the Computer Use agent automatically uses these stored credentials to authenticate. If additional verification, such as Multi-Factor Authentication (MFA), is required, the assigned reviewer can respond to the agent’s request and allow the execution to continue.

Step 7:
Sign in to Power Automate by navigating to https://powerautomate.microsoft.com/. From the left navigation pane, select Create, choose Instant cloud flow, and then select the When an agent calls the flow trigger. This trigger enables the flow to be invoked directly from a Copilot Studio agent, allowing it to process the data extracted by the Computer Use tool.

Provide an appropriate name for the flow and click Create to continue.

Step 8:
In the When an agent calls the flow trigger, add a Text input named ExtractedJson. This input will receive the JSON data returned by the Computer Use tool.

Next, add a Parse JSON action and set the Content field to the ExtractedJson input. Generate the schema using a sample of the JSON returned by the Computer Use agent. This enables Power Automate to interpret the extracted data and make each property available for subsequent actions.

After parsing the JSON, add the Create CSV table action. Set the From field to the Body output of the Parse JSON action. This converts the extracted table data into a CSV format that can be used in downstream actions, such as sending it as an email attachment.

This step prepares the extracted PDF data for further processing within the flow.

Step 9:
After generating the CSV data, add a Create file action (OneDrive for Business) to save the CSV file temporarily. Specify the destination folder, provide a meaningful file name (for example, PurchaseOrder_<timestamp>.csv), and set the File Content to the Output from the Create CSV table action.

Next, add a Get file content action and set the File field to the Id returned by the Create file action. This retrieves the contents of the generated CSV file, allowing it to be used in subsequent actions, such as sending it as an email attachment.

Step 10:
Add a Send an email (V2) action to the flow. Configure the recipient’s email address, provide an appropriate subject, and compose the email body. Under Attachments, use the file content obtained from the Get file content action and specify the CSV file name. This sends the generated CSV file as an email attachment to the intended recipient.

Finally, add the Respond to Copilot action. Return a success response indicating that the flow completed successfully. For example, you can return the following JSON:

{

“Status”: “Success”,

“Message”: “CSV generated and emailed successfully.”

}

Step 11:
Save and enable the Power Automate flow. Return to your Copilot Studio agent and edit the agent instructions to orchestrate the complete process. The instructions should direct the agent to invoke the Computer Use tool to extract the table data from the PDF and then pass the extracted JSON to the Power Automate flow for further processing.

For example, you can use instructions similar to the following:
Whenever a PDF is added or updated in the specified SharePoint document library, invoke the Computer Use tool to extract the primary table from the PDF. Once the extraction is complete, pass the returned JSON to the Power Automate flow to generate a CSV file and email it to the configured recipient.

After saving the instructions, publish the agent. The agent is now configured to use the Computer Use tool for PDF table extraction and the Power Automate flow for generating and emailing the CSV output.

Test Results:
After publishing the Copilot Studio agent, invoke it by providing a prompt to extract the table from the Purchase Order PDF stored in the SharePoint document library.

During execution, the agent performs the following actions:

• Opens the PDF directly from SharePoint using the Computer Use tool.
• Authenticates using the configured stored credentials.
• Identifies the primary table containing the purchase order line items.
• Extracts the complete table into a structured JSON format.
• Invokes the Power Automate flow.
• Converts the JSON data into a CSV file.
• Sends the generated CSV file as an email attachment to the configured recipient.

Conclusion: In this blog, we built an end-to-end solution using Microsoft Copilot Studio Computer Use and Power Automate to automate the extraction of tabular data from a PDF stored in SharePoint. The Computer Use tool interacted with the PDF through its user interface, extracted the required table into a structured JSON format, and passed the data to a Power Automate flow. The flow then converted the extracted data into a CSV file and emailed it to the intended recipient.

Frequently Asked Questions (FAQs)

1. What is Computer Use in Microsoft Copilot Studio?

Computer Use is a capability in Microsoft Copilot Studio that enables agents to interact with applications through their graphical user interface (GUI). Instead of relying on APIs, the agent can open applications, navigate screens, extract information, and perform tasks based on what it sees.

2. Can Copilot Studio extract data from PDF files?

Yes. By using the Computer Use capability, a Copilot Studio agent can open PDF documents, identify tables or other relevant information, and extract the data into a structured format such as JSON for further processing.

The post Automating PDF Data Extraction Using Computer Use within Copilot Studio first appeared on Microsoft Dynamics 365 CRM Tips and Tricks.

Organizations today store massive volumes of structured data sales figures, inventory records, and financial reports in Excel and CSV files across SharePoint libraries. When someone needs a quick insight from that data, the typical path involves downloading the file, opening it in Excel or Power BI, writing formulas or building visuals, and then sharing the result. It works, but it’s slow, manual, and requires a level of technical skill that not every team member has.

What if there was a way to simply ask a question and get the answer complete with accurate calculations and even a chart without ever leaving a chat window.

That’s the promise of Code Interpreter in Microsoft Copilot Studio. This preview feature allows Copilot Studio agents to go beyond simple Q&A by dynamically generating and executing Python code to analyze structured data files. When paired with a SharePoint Document Library as a knowledge source, it creates a powerful self-service analytics experience: users ask questions in plain English and the agent does the heavy lifting searching SharePoint for the right file, writing the code, running the computation, and delivering the result.

In this blog, we’ll explore what Code Interpreter is, how it works with SharePoint, and see it in action.

Code Interpreter is a capability within Microsoft Copilot Studio that enables AI agents to generate and execute Python code on the fly in response to user queries. Rather than relying solely on the large language model’s inherent reasoning which can be unreliable for math and data-heavy questions Code Interpreter offloads analytical tasks to deterministic Python computations.

The agent doesn’t estimate the answer. Instead, it writes a precise Python script, runs it against the actual data, and returns the calculated result. The math is real. The answer is accurate. And the user never sees a single line of code unless they choose to.

You can enable code interpret in the agent setting in Generative AI, scrolling down you will find the option for code interpreter and enable that.

There are two ways to feed structured data into a Copilot Studio agent for analysis. The first is user-uploaded files where someone attaches a CSV or Excel file directly in the chat. The second, and more enterprise-relevant approach, is connecting a SharePoint Document Library as a knowledge source. In this blog, we focus on the SharePoint approach.

When a user asks an analytical question, the agent follows a multi-step process behind the scenes:

1. Understand the query: The orchestrator interprets the natural language question and determines it requires data analysis.
2. Search SharePoint: The agent uses Work IQ Microsoft’s enhanced retrieval layer to search the connected SharePoint knowledge source and locate the relevant structured file.
3. Retrieve and inspect: The agent retrieves the file content and examines its structure columns, data types, and rows.
4. Generate Python code. Based on the query and the data, the agent writes a Python script tailored to answer the question.
5. Return the result. The output a table, a chart, a number, or a summary is delivered back to the user in the chat.

To demonstrate this capability, we have two structured datasets stored in a SharePoint Document Library SalesReport.xlsx containing employee-level sales performance data, and BusinessSalesAnalysis.xlsx containing order-level business data with products, categories, regions, and revenue.

With Code Interpreter enabled and the SharePoint files connected as a knowledge source, the agent can now answer analytical questions directly. Let’s see how it responds to a couple of queries.

Below are some of the question asked to the agent.

Query 1: “Which product category generated the highest revenue in the uploaded Excel report?”

The agent identified the relevant file, executed Python code to calculate revenue by product category, and returned a clear breakdown Electronics leading at $738,000 followed by Furniture at $517,000. It even highlighted key revenue drivers like Laptops and Monitors.

Query 2:  Analyze the uploaded sales dataset and provide a summary of overall business performance.

This time, the agent analyzed both datasets together and returned a comprehensive summary $1,255,000 in total revenue, $286,000 in profit, 321 units sold, and a 22.79% profit margin. It also generated a month-over-month revenue and profit trend table from January through May.

As you can see, the agent has used the Code Interpreter to answer the user’s queries generating Python code behind the scenes, running real calculations against the SharePoint data, and returning accurate, formatted results directly in the conversation. No manual data work. No formulas. Just a natural language question and a precise answer.

Conclusion

Code Interpreter in Microsoft Copilot Studio brings real computational power to the conversational AI experience. By combining natural language understanding with deterministic Python execution and grounding it in the structured files already living in SharePoint it creates a genuinely useful self-service analytics layer. Users ask questions in plain language. The agent finds the data, writes the code, runs the computation, and delivers the answer all within seconds.

FAQs

What is Code Interpreter in Microsoft Copilot Studio?

Code Interpreter is a capability in Microsoft Copilot Studio that enables AI agents to generate and execute Python code automatically. It allows agents to perform data analysis, calculations, visualizations, and file processing based on user queries, delivering accurate results directly within a conversation.

How does Code Interpreter work with SharePoint files?

When SharePoint Document Libraries are connected as a knowledge source, the Copilot Studio agent can locate relevant Excel or CSV files, analyze their contents, generate Python code to answer user questions, execute the code, and return insights such as summaries, calculations, tables, or charts.

Can Microsoft Copilot Studio analyze Excel files stored in SharePoint?

Yes. Microsoft Copilot Studio can analyze Excel files stored in SharePoint when the library is configured as a knowledge source and Code Interpreter is enabled. Users can ask questions in natural language, and the agent retrieves and analyzes the data automatically.

What types of files can Code Interpreter analyze?

Code Interpreter primarily supports structured data files such as Excel (.xlsx) and CSV (.csv) files. These files can be uploaded directly by users or accessed through connected SharePoint Document Libraries.

Why is Code Interpreter more accurate for data analysis?

Unlike traditional AI responses that rely on probabilistic reasoning, Code Interpreter generates and executes actual Python code against the source data. This ensures calculations, aggregations, and analytical results are based on real data processing rather than estimation.

The post Streamlining SharePoint File Analysis with Microsoft Copilot Studio Code Interpreter first appeared on Microsoft Dynamics 365 CRM Tips and Tricks.

Organizations frequently receive employee requests for training programs, certifications, or skill-development courses. Traditionally, these requests go through manual review and approval processes which can delay decision making and create administrative overhead.

With Advanced Approvals in Microsoft Copilot Studio, it is possible to automate such decisions using AI. Instead of relying on human approval stages, AI can evaluate the request details and decide whether the request should be approved or rejected based on predefined criteria.

In this article, we will build a Training Request Approval System where:

• A user creates a training request record in Dataverse
• An AI approval stage evaluates the request
• The AI automatically approves or rejects the request

This implementation demonstrates how AI-driven approvals can automate business decisions without human intervention.

Prerequisites

Before starting, ensure the following are available:

• Access to Microsoft Copilot Studio
• A Power Platform environment with Dataverse enabled
• Basic knowledge of Dataverse tables and Copilot Studio agent flows

Solution Overview

The workflow implemented in this article follows a simple structure.

1. Employee submits a training request
2. The request is stored in Dataverse
3. AI evaluates the request
4. The system updates the approval status

This removes the need for manual manager approvals and allows faster decision making.

Step 1: Create a Dataverse Table for Training Requests

First, create a Dataverse table that will store the training requests.

Example table: Training Requests

Suggested columns:

This table will be used by the AI flow to read and update request details.

Step 2: Create an Agent Flow in Copilot Studio

Navigate to Copilot Studio → Agent Flows and create a new flow.

Agent flows allow you to automate processes using AI and actions connected to data sources like Dataverse.

In this implementation, the agent flow will:

• Retrieve the training request
• Evaluate the request using AI
• Update the request status.

Agent Flow creation screen in Copilot Studio

Step 3: Configure the Multistage Approval Step

Add the Run a multistage approval action in the flow.

This feature allows AI to evaluate requests based on specific instructions.

Since this implementation focuses on AI-only approval, no manual stages are added.

The flow will only contain the Evaluate Request AI stage.

Run a multistage approval (preview) configuration screen

Step 4: Define AI Evaluation Instructions

Inside the Evaluate Request step, define clear instructions for the AI model so it knows how to evaluate the request.

Example instructions:

Evaluate the employee training request and decide whether it should be Approved or Rejected.

APPROVE the request if ALL of the following are true :

– The trainingCost <= 1000.00

– trainingStartDate is after the date the course is purchased (i.e. coursePurchaseDate)

– The request contains all required details including employeeName, courseName, trainingCost, and trainingStartDate.

REJECT the request if any of the above are false.

Note: Here trainingCost, trainingStartDate, employeeName, courseName, coursePurchaseDate are dynamic fields as shown below in the image

These instructions guide the AI model to consistently evaluate each training request.

AI instruction configuration inside the Evaluate Request stage

Step 5: Update the Dataverse Record

After the AI evaluates the request, configure the next step in the flow to update the Dataverse record.

Based on the AI decision:

• If Approved → Update Approval Status to Approved
• If Rejected → Update Approval Status to Rejected

This ensures the final decision is stored directly in Dataverse.

Dataverse Update Row action in the flow

Testing the AI Approval Process

Once the flow is configured:

1. Create a new training request record
2. Trigger the agent flow
3. Observe the AI evaluation
4. Verify that the Approval Status updates automatically

This demonstrates how AI can independently make approval decisions based on defined rules.

Dataverse Update Row action flow when all conditions are met / true

Dataverse Update Row action flow when all conditions are not met / false

Example training request record before and after AI evaluation

Challenges You May Encounter

While implementing AI approvals in Copilot Studio, you may encounter some configuration challenges.

1.Writing Effective AI Instructions

The AI model relies heavily on the instructions provided. If instructions are vague, the decision may be inconsistent.

To avoid this:

• Clearly define approval and rejection conditions
• Keep the logic simple and structured.

2.Mapping Dataverse Fields

Incorrect field mapping between the agent flow and Dataverse may prevent the AI from reading request data correctly.

Always verify:

• Column names
• Data types
• Input parameters passed to the AI stage.

3.Understanding AI Decision Outputs

The AI stage returns structured output which must be correctly interpreted when updating Dataverse records. Improper condition checks may cause incorrect status updates.

4.Preview Feature Limitations

The Multistage Approval feature is currently in preview, so some UI elements or configurations may change over time.

Benefits of AI-Driven Approvals

Implementing AI-based approvals provides several advantages:

• Faster decision making
• Reduced dependency on manual approvals
• Scalable automation
• Consistent evaluation logic
• Seamless integration with Dataverse

Conclusion

Advanced approvals in Microsoft Copilot Studio open new possibilities for automating decision-based workflows. In this example, we built a Training Request Approval System where AI evaluates each request and determines whether it should be approved or rejected.

FAQs: Automating Training Request Approvals with AI in Microsoft Copilot Studio

• What is AI-driven approval in Microsoft Copilot Studio?
  AI-driven approval in Microsoft Copilot Studio automates the decision-making process for requests, such as employee training requests. Instead of waiting for human manager approval, AI evaluates the request based on predefined rules and updates the approval status automatically in Dataverse.
• How does the training request approval system work?
  The system works in a few steps:

1. An employee submits a training request in Dataverse.
2. The AI agent flow in Copilot Studio retrieves the request.
3. The AI evaluates the request against predefined approval criteria.
4. The AI updates the request status as Approved or Rejected.

• What are the prerequisites for setting up AI approval in Copilot Studio?
  To implement AI-based training approvals, you need:

1. Access to Microsoft Copilot Studio.
2. A Power Platform environment with Dataverse enabled.
3. Basic knowledge of Dataverse tables and Copilot Studio agent flows.

• Can AI completely replace human approval for training requests?
  Yes, AI can handle approval entirely if the evaluation logic is clearly defined. AI ensures faster, consistent, and scalable approvals, reducing administrative overhead. However, organizations can still add manual review stages if needed.

The post Automating Training Request Approvals Using AI in Microsoft Copilot Studio first appeared on Microsoft Dynamics 365 CRM Tips and Tricks.

Deep Reasoning in Microsoft Copilot Studio enables AI agents to analyze multi-step support scenarios, evaluate historical case data, apply business rules, and recommend well-reasoned actions similar to how an experienced support specialist thinks.

AI agents are becoming a core part of customer service operations, but traditional conversational models often struggle when scenarios become complex, like diagnosing a multi-step issue, understanding multi-turn case histories, or recommending the next best action.
Microsoft’s new Deep Reasoning capability in Copilot Studio (currently in preview) bridges this gap by enabling agents to think more logically and deliver more accurate conclusions.

This feature equips Copilot agents with advanced analytical abilities similar to how a skilled support specialist breaks down a problem, evaluates evidence, and suggests well-reasoned actions.

How Deep Reasoning Works

Deep reasoning is powered by an advanced Azure OpenAI model (o3), optimized for:

• Multi-step thinking
• Logical deduction
• Complex problem solving
• Chain-of-thought analysis
• Context comprehension across long conversations

When enabled, the agent automatically decides when to invoke the deep reasoning model, especially during:

• Complicated queries
• Multi-turn conversations
• Tasks requiring decision making
• Summaries of large case files
• Applying business rules

Alternatively, you can instruct the agent to explicitly use deep reasoning by including the keyword “reason” in your agent instructions.

Business Use Case:

Imagine a company that manages thousands of service cases, technical issues, warranty requests, customer complaints, and product inquiries.
Handling these efficiently requires deep understanding of:

• Historical case data
• Case descriptions across multiple interactions
• Dependencies (products, warranties, previous repairs, SLAs)
• Business rules
• Customer communication patterns

A standard AI model can answer simple questions, but when a customer or sales representative asks something like:

• Why was this customer’s case reopened three times?
• Given the reported symptoms and past activity, what should be the next troubleshooting step?
• Which SLA should be applied in this situation, and what is the reasoning behind it?
• Considering the notes from all three departments, what appears to be the underlying root cause?

Your agent needs more than a direct lookup.
It needs reasoning.

This is where Deep Reasoning dramatically improves the experience.

How to Enable Deep Reasoning in Copilot Studio (Step-by-Step)

Setting up deep reasoning in a Copilot Studio agent is straightforward:

Step 1. Enable generative orchestration

This allows the agent to decide intelligently which model should handle each part of the conversation.

Step 2. Turn on Deep Reasoning

When enabled, the o3 model is added to the agent’s orchestration pipeline.

Step 3. Add the reason keyword (optional but recommended)

Inside the Agent Instructions, specify where deep reasoning should be applied:

As mentioned in the screenshot below, the word “reason” is used twice to trigger deep reasoning in our custom agent.

Step 4. Connect data sources

You can link multiple sources such as:

• Dataverse Cases table
• Knowledge bases
• SharePoint documents
• Product manuals
• Troubleshooting guides

Deep reasoning enables the agent to interpret and analyze these materials more effectively.
For this example, I connected a Dataverse MCP server to provide the agent with improved access to Dataverse tables.

Step 5. Test complex scenarios

Ask real-world questions like:

• Analyze the case history and determine the most likely root cause.
• Based on the customer’s issue description, what steps should the technician take next?
• Explain why this case breached SLA.

You will notice the agent provides a structured, logical answer rather than surface-level information.

You can also verify that deep reasoning was activated by checking the Activity section.

Frequently Asked Questions About Deep Reasoning in Copilot Studio

What model powers Deep Reasoning in Copilot Studio?
Deep Reasoning is powered by the Azure OpenAI o3 reasoning model, optimized for multi-step analysis and logical deduction.

When should Deep Reasoning be used?
It should be applied to complex, multi-turn conversations involving business rules, SLAs, historical data, or decision-making.

Does Deep Reasoning replace standard Copilot responses?
No. Copilot Studio dynamically decides when Deep Reasoning is required, using standard models for simpler interactions.

Can Deep Reasoning analyze large case histories?
Yes. It is specifically designed to interpret long conversations and large volumes of contextual data.

Conclusion

By connecting rich data sources and enabling deep reasoning, the agent becomes significantly more capable of understanding complex case scenarios and providing meaningful, actionable responses. When tested with real-world questions, the agent demonstrates structured analysis, logical decision-making, and deeper insights rather than surface-level replies.

This ensures more accurate case resolutions, improved productivity, and a smarter, more reliable support experience.

The post How Copilot Studio Leverages Deep Reasoning for Intelligent Support Operations first appeared on Microsoft Dynamics 365 CRM Tips and Tricks.