Dataverse Plugin for Coding Agents: Marketplace Expansion 

The Dataverse plugin for coding agents brings the full power of Microsoft Dataverse directly into the developer’s coding environment. Instead of switching between browser tabs, documentation, and admin portals, developers can describe what they want in natural language and the plugin handles the rest. It intelligently routes each request through the right tool, whether that’s the Dataverse MCP server (see latest update), the Python SDK, PAC CLI, or the Dataverse CLI, so developers stay in flow and get production-grade results without needing to master every tool individually. Built on an open-source skill architecture, the plugin enforces least-privilege security, follows documented auth patterns, and respects existing Dataverse RBAC, making it safe for real enterprise environments from day one. See the Dataverse plugin for coding agents in action here.  

We are excited to announce the expansion of the Dataverse plugin into additional coding agent marketplaces, meeting developers where they already work. The plugin is now available for Claude, Cursor and GitHub Copilot. This means that whether a developer’s primary coding agent is GitHub Copilot, Claude or Cursor, they get the same Dataverse expertise: intelligent skill routing, enterprise-grade guardrails, and a consistent natural-language experience across every surface. This cross-platform availability reflects our commitment to making Dataverse accessible wherever agents are being built, and we will have support for more coding agents coming soon. 

A Growing MCP Ecosystem Connected to the Systems You Already Run 

Model Context Protocol (MCP) servers give agents a common way to discover and use tools across systems: one standard connection model that helps any agent work with the right tool, in the right system, at the right time. Microsoft is building a rich MCP catalog designed around the systems enterprises already depend on — from productivity and developer experiences to business applications and partner platforms.

The catalog includes 60+ ready MCP servers, and the customer promise is simple: start faster with ready-to-use MCPs, connect agents to familiar business systems, and use the same standard across Microsoft 365 Copilot, Copilot Studio, Azure AI Foundry, GitHub Copilot, and other MCP-compatible experiences. For example, the Dataverse MCP server is natively supported today in Copilot Studio, Azure AI Foundry, and other MCP-compatible clients. 

Certified MCPs: ISV Built MCPs that Customers Can Discover, Trust, and Govern 

For ISVs and partners, MCP certification creates a trusted route into the Microsoft ecosystem. Once certified, partner-built MCPs become easier for customers to discover, evaluate, and adopt, while signaling that the experience aligns with enterprise expectations around security, governance, and observability. For customers, certified MCPs help reduce uncertainty: they can look to a growing ecosystem of partner capabilities designed to extend agents into specialized business scenarios, with clearer trust signals and a path toward governed adoption at scale. 

1. Package your MCP for certification. Prepare a certification package that includes your MCP manifest (with the MCP endpoint URL), Tools JSON file, and Key Vault-backed authentication details for securely managing secrets. 

2. Choose your certification offer type. Select the appropriate certification offer type ‘Apps and Agents for M365 and Copilot’ for your MCP and submit the package through Partner Center to make your MCP available across Microsoft agent experiences. 

3. Publish across Microsoft experiences. Once certified, your MCP becomes available for customer adoption across supported Microsoft surfaces, including Copilot Studio and Azure AI Foundry, making it easier for customers to discover, trust, and use your MCP in enterprise AI solutions. 

Bring Your Own MCP: Your Internal Tools, Governed Like the Catalog  

Beyond the rich MCP catalog, Bring Your Own MCP enables organizations to connect their unique business systems and workflows to the agent ecosystem. If your organization has a custom tool, proprietary API, internal workflow, or industry-specific system, you can bring that MCP server into your own organization and make it available for agents under enterprise controls. The goal is to give customers flexibility without giving up governance: register the MCP once, make it discoverable for the right agent scenarios, and manage it with the same expectations for admin approval, visibility, and control. 

Dataverse agentic evolution: from experimentation to execution  

As AI becomes a coding partner, Dataverse gives makers and developers the trusted data platform to build apps and agents faster, with the business context, connected tools, and enterprise governance needed to move from experimentation to execution. Learn more:  

Dataverse MCP: Dataverse MCP Server: Understanding the New Tool Shape – Microsoft Power Platform Blog

Dataverse MCP preview docs: https://learn.microsoft.com/en-us/power-apps/maker/data-platform/data-platform-mcp-preview-tools 

Dataverse Plugin on Claude Marketplace announcement blog: https://devblogs.microsoft.com/powerplatform/dataverse-plugin-claude-marketplace/ 

For ISVs and partners, check out the MCP certification to creates a trusted route into the Microsoft ecosystem

Read the Bring Your Own MCP docs

Dataverse docs: https://learn.microsoft.com/en-us/power-apps/maker/data-platform/data-platform-intro 

The post Dataverse Is Your Agent Data Platform: Here’s What’s New in July 2026 appeared first on Microsoft Power Platform Blog.

This matters because MCP already gives makers and developers a consistent way to connect agents to real business data without every client needing a custom Dataverse integration. Our enhancements ensure the Dataverse MCP experience is easier to reason about through a clearer tool shape. Agent surfaces like Copilot Studio, GitHub Copilot in VS Code, GitHub Copilot CLI, Claude Desktop, Claude Code, and other MCP-compatible clients can now connect to the Dataverse MCP endpoint and experience this new tool shape.

What changed

The important change is not that Dataverse supports MCP. It already does. The change is that the experience is now easier to understand through a concrete set of tools. Instead of thinking about MCP as a generic connection, we can now talk about the actual tools an agent can use. The Dataverse MCP server exposes tools for common data and metadata tasks, including:

This tool shape is important because it defines the contract between the agent and Dataverse. The agent is not just connected to Dataverse in a broad sense. It has a set of named capabilities that can be reasoned about, allowed, blocked, audited, and improved over time.

For additional information, please see the documentation for full list of Dataverse MCP tools and billing rates.

Why the tool shape matters

For users, makers, and pro developers, the MCP tool shape creates a cleaner mental model.

If an agent needs to:

• Understand the data model, it can use tools such as search, describe, and schema-related responses.
• Answer a question from data, it can use read_query or search_data depending on whether the scenario is structured query or broader search.
• Create or update business data, it can use create_record, update_record, or delete_record with the right approvals and safeguards.
• Help scaffold or evolve a simple schema, it can use table tools such as create_table, update_table, and delete_table.
• Move files in or out of Dataverse, it can use init_file_upload, commit_file_upload, and file_download.

That means agent experiences can move from “tell me how to do this” to “help me inspect, reason, and act against my environment,” while still going through explicit tool boundaries.

A practical example

Imagine a user asks: Which accounts have open follow-up items, and can you create a task for the ones missing an owner?

With the MCP server connected, the agent can use the Dataverse tools to inspect the relevant tables, query the data, and create records where appropriate. The interaction becomes more grounded because the agent can work with the actual Dataverse environment instead of relying only on user-provided context.

Governance still matters

The MCP server does not remove the need for governance. In fact, the tool shape makes governance more visible.

Administrators have control over which clients have access to to the environment via MCP server. This ensures that only approved agent surfaces are accessing business data. Additional capabilities such as ‘allowed tools’ and strong role based access control ensure users only have access to data that their security context allows.

The practical guidance is:

1. Enable MCP only for environments where agent access makes sense.
2. Allow only approved clients.
3. Understand which tools are exposed.
4. Treat write-capable tools differently from read-only tools.
5. Validate that users only access data they are already permitted to see.

Summary

The most interesting part of this Dataverse MCP server enhancement is the move toward a clearer, more concrete tool shape.

The updated tool shape makes Dataverse more agent-ready. It gives agents a standard way to discover tables, inspect schema, query data, and use controlled Dataverse tools. For makers, this means more natural AI-assisted workflows. For developers, it means a cleaner integration pattern. For admins, it creates a more explicit surface to govern.

MCP turns Dataverse into something agents can use directly, but the tool shape determines how safe, useful, and predictable that experience becomes.

Additional resources

• Connect to Dataverse with Model Context Protocol
• Configure the Dataverse MCP server for an environment

The post Dataverse MCP Server: Understanding the New Tool Shape appeared first on Microsoft Power Platform Blog.

Companion post to our Build 2026 session: Microsoft Dataverse plugin: unleashing coding agents on the enterprise

Coding agents are powerful, but without domain tooling they hallucinate and produce broken solutions. The Dataverse plugin for coding agentssolves this by giving AI agents guardrailed access to tables, columns, relationships, views, security, and solutions.

In our Build 2026 session, we showed how a natural-language request triggers multi-step provisioning, data imports, and validation. This is all executed autonomously, through the plugin’s tool integration and patterns that make agent-driven Dataverse development reliable at scale.

To bring this to life, we built a series around Zava Coffee Co., a growing B2B roaster and distributor running on spreadsheets, email, and copy-paste. When it came time to modernize, they didn’t need a massive team and spend weeks in the the various portals. Instead, they installed the Dataverse plugin and described what they needed, in plain English, from a GitHub Copilot terminal.

This post, and accompanying video, walks through the three scenarios:

1. Maya, a developer building her first data model, app form and view
2. Riya, a Revenue Ops analyst running her CRM in natural language
3. Amara, a platform admin locking down security across two regions.

Scenario 1: Zero to App in One Session

Persona: Maya, Developer, new to Dataverse
Goal: Turn four operational spreadsheets into a working Dataverse application with schemas, relationships, and real data.

Maya had never touched Dataverse. She didn’t know her org URL, didn’t know what a publisher prefix was, and shouldn’t have to. She installed the plugin, typed one sentence “Connect me to my Dataverse environment” and the agent discovered her environments from her Microsoft identity, configured everything, and verified the connection.

Then she describes her roast batch tracking system in business terms: beans, batches, quality checks, orders, and the relationships between them. One prompt produced four tables with choice columns, lookups, a self-referential parent-batch relationship for re-roasts, a many-to-many between batches and orders, a main form, and a filtered view — all packaged in a solution.

The data import is where it gets real. Maya pointed the agent at the team’s four Excel files. No GUIDs anywhere, just business keys for a bean variety and batch numbers. The agent figured out dependency order, loaded parent tables first, resolved the self-referential re-roast links, split a comma-separated batch list into proper many-to-many associations, and left an unlinked order alone instead of erroring out. That’s a data pipeline, not a sample generator.

What the plugin solved: Maya went from zero Dataverse knowledge to a connected, working application that included schemas, relationships, forms, views, and three years of real operational history, all without opening the maker portal, reading a setup guide, or writing a single line of FetchXML.

Scenario 2: Talk to Your CRM in Plain English

Persona: Riya, RevOps Analyst
Goal: Run Friday pipeline prep in five minutes instead of forty-five minutes, no Advanced Find, no Excel pivots, no chasing teammates in Teams.

Riya already lives in a terminal. Every Thursday she preps Carlos’s sales pipeline review by pulling open deals, flag at-risk cafés, makes sure last week’s calls are logged. Today that’s forty-five minutes of Advanced Find queries, Excel exports, and detective work.

With the Dataverse plugin, she asked: “Show me Carlos’s open opportunities over $100K closing this quarter.” The agent looked up Carlos by name in the systemuser table, translated “this quarter” into a date range, and returned café names, deal names, dollars, and stages — no GUIDs, no statecode = 0, no estimatedclosedate syntax.

Then she asked for “cafés in Portland that haven’t reordered in 30 days.” That’s not a field, it’s a relationship plus date math. The agent joined accounts to closed-won opportunities, computed the gap, and handed Riya a clean call list.

The trust moment: When Riya said “Add a note to the Portland cafe opportunity,” the agent found the open deal on that account. She also logged a phone call on behalf of Carlos, the agent set the owner to Carlos (his call), marked it completed (already happened), resolved the contact as a participant, and linked it to the right account, all inferred from one sentence.

What the plugin solved: Riya collapsed 45 minutes of Advanced Find, Excel pivots, and manual activity logging into five minutes of conversational CRM access. Carlos got a cleaner pipeline review without doing anything differently.

Scenario 3: Manage Your Environment Like a Pro

Persona: Amara, Platform Admin
Goal: Draw security boundaries for two regions and three job functions, validate every line, and package it in a deployable solution.

Zava doubled in size and opened a Seattle hub. Amara’s problem: warehouse staff can see deal sizes, sales reps can see quality scores, and anyone can read customer lifetime value. She needed to draw lines and she wanted to describe the security model once, not click through six sections of the admin portal.

She connected with an admin posture: “Verify I have System Administrator privileges before we start.” The agent confirmed her role before offering to do anything destructive. Then she described the full security plan in one prompt: two business units (Portland, Seattle), three custom roles scoped appropriately, field-level security on the sensitive lifetime_value column, an access team template for cross-region collaboration, and three user assignments, all in a ZavaSecurity solution.

The invisible prerequisites: The agent enabled the column for field-level security at the schema level before creating the Field Level Security (FLS) profile. This step, when missed, produces no error and no audit entries. It assigned the profile to roles, because a created-but-unassigned profile does nothing. It added every security component to the solution explicitly, since roles and FLS profiles don’t auto-add.

Validation by impersonation: Amara asked the agent to simulate each user’s access. The result was a clear pass/fail table — Diego can read accounts but not lifetime_value (FLS), Marcus can read roast batches but not accounts (role), nobody can see across business units. Red Xs and Green checkmarks in all the right places, with the why annotated next to each cell. That’s the admin equivalent of a unit test. Allconfiguration confirmed in seconds, not browser-tab-per-user.

She then shared one record cross-region via the access team template. This was one sentence, no GUIDs and enabled three-layer column auditing (org, table, column) so future reads are logged.

What the plugin solved: In one session, Amara stood up two BUs, three roles, FLS with proper assignments, a team template, three user assignments, validated by impersonation, configured a cross-region share, and turned on auditing. Every component lives in a solution she can version and redeploy across environments.

Three Users, Three Jobs, One Unified Approach

The common thread across all three scenarios is : describe your intent in plain language, the agent translates it into the right combination of Dataverse operations. Maya never learned what a publisher prefix is. Riya never wrote FetchXML. Amara never opened the BU management UI. Each person brought a different problem and a different level of platform expertise and the same plugin met all three where they were.

The Dataverse Skills pluginis available now on the Claude and GitHub Copilot marketplaces. Install it, connect, and start building.

👉 Watch the full Build 2026 session:  Microsoft Dataverse plugin: unleashing coding agents on the enterprise 

Learn more about what’s new in Dataverse: aka.ms/DataverseMay2026

The post Microsoft Dataverse Plugin: Unleashing Coding Agents on the Enterprise – Microsoft Build 2026 appeared first on Microsoft Power Platform Blog.

With GA, the plugin now covers the part of the journey that decides how your website project reaches your users, i.e., getting to production safely. You get Application Lifecycle Management (ALM) with the native Power Platform Pipelines, security hardening for your live site, and an expanded selection for authentication setup, all through the same conversational workflow you already know.

What’s new at GA

The preview helped you build. GA helps you ship, govern, and protect what you build.

• ALM and pipelines. Promote your site from development to test to production with native Power Platform Pipelines, no external infrastructure required.
• Site security. Configure a web application firewall, tighten browser security headers, scan your live site for vulnerabilities, and audit table permissions before you go live.
• Authentication and access. The /setup-auth skill now configures more than one identity provider, generates registration and profile pages.

Everything from the preview is still included, generally available and production supported: site creation, deployment, activation, data modeling, Web API integration, server logic, cloud flows, and SEO.

Move to production with ALM and pipelines

A site that lives only in a development environment isn’t finished. The new ALM skills package your site into a Dataverse solution and deploy it across environments using pipelines in Power Platform, Microsoft’s native, in-product Continuous Integration and Continuous Delivery (CI/CD). There is no separate build server to stand up and no specialized ALM knowledge required to get started.

Describe what you want, and the plugin runs the right skills. Start with /plan-alm if you’re not sure where to begin: it’s the orchestrator and runs the other skills for you. If you already know what you need, run a direct skill on its own.

Whichever path you take, the deployment plan is reviewable before anything runs, so you decide the promotion path and approvals up front. The plugin then handles the export, import, version handling, and environment wiring that used to be manual, repetitive work.

Secure your site for production

Going to production for an external website means exposing your site to the open internet. The new security skills help you close common gaps without leaving your agent session, and each one explains what it found in plain language. Start with /security-review if you’re not sure where to begin, it’s the skill orchestrator which steps you through the others. If you want to target one area, run a direct skill on its own.

Whichever path you take, the plugin recommends a safe configuration, shows you the implications, and waits for your approval before making any change.

Set up authentication and access

Authentication is one of the first things a real site needs, and small misconfigurations are common. The improved /setup-auth skill generates a clean sign-in and sign-out flow with anti-forgery token handling, and it now goes further:

• More than one identity provider. Beyond the default Microsoft Entra ID provider, configure additional identity providers, such as other OpenID Connect or OAuth 2.0 providers, so you can offer the sign-in options your users expect.
• Registration and profile pages. Give users a way to sign up and manage their own account details, not just sign in and out.

Paired with /create-webroles, you can stand up authenticated access, self-service registration, and role-aware UI in a single conversation.

You stay in control

As in preview, the plugin proposes and you approve. The Data Model Architect, Web API Permissions Architect, and Server Logic Architect agents present their plans before making changes, and the new ALM and security skills follow the same pattern. Nothing is created, deployed, or hardened until you confirm.

Get started

Install or update the plugin and PAC CLI

If you’re new to the plugin, install it from the Microsoft marketplace and restart your agent. For the easiest setup, use Quick Install (recommended),

Already building with the preview? Turn on auto-update from the /plugin menu, or reinstall to pick up the GA skills. Then try the new flow end to end: run /create-site to build, /security-review to harden, and /plan-alm to promote your site to production.

Get started with the Power Pages plugin for GitHub Copilot CLI and Claude Code.

We are looking for your feedback

Your feedback helps us improve the developer experience on Power Pages. Share your thoughts and reach out on the Power Pages Community Forum. You can also submit ideas through the Power Pages Ideas portal.

Resources

• Get started with the Power Pages plugin for GitHub Copilot CLI and Claude Code
• Pipelines in Power Platform
• Use Power Platform pipelines with Power Pages
• Web Application Firewall for Power Pages
• Manage your site’s Content Security Policy
• GitHub Copilot CLI and Claude Code

The post Build Power Pages Sites with AI through Agentic Coding tools, now Generally Available appeared first on Microsoft Power Platform Blog.

Today, we’re introducing closed-loop learning for agents connected to the Power Apps MCP server, starting with the data entry tool. Every correction a user makes through the Agent feed persists as structured memory. On future runs, the agent retrieves that memory and applies it. Over time, those corrections consolidate into organization-wide patterns the agent applies across tasks. The feedback loop runs automatically in production. Nothing to configure, no data pipelines to build.

How closed-loop learning works

Say a finance team has an agent to process vendor invoices. The agent uses the data entry tool in the Power Apps MCP server to extract supplier names, addresses, and totals from PDFs. Most fields come through correctly, and the agent correctly fills in “UK” from the document, but the organization requires it to be normalized to “United Kingdom.” A user corrects it in the Agent feed. After a handful of corrections like this, the pattern becomes the agent’s memory. The next invoice with “UK” gets “United Kingdom” automatically. Over time, the system learns the pattern: abbreviations like “USA” or “DE” get expanded too. The agent also learns by example: it retrieves similar memories to the current request and applies the same processing steps used previously.   

Think of it like a driving instructor in the passenger seat. A student merges without checking the blind spot; the instructor corrects them, and the student remembers it for next time, because they wrote it down. That’s the first layer: memory-based optimization, the mechanism that captures individual corrections and applies them on future runs.

Corrections get you through the driving test. Patterns make you a confident driver. That’s the second layer: Genetic-Pareto optimization, an evolutionary prompt optimization technique. Memory-based optimization generalizes from the corrections it remembers. Genetic-Pareto goes further, distilling those corrections into rules compiled into the agent’s instructions, so the principle becomes the agent’s default behavior rather than a pattern it must retrieve each time. Both layers are live today for the data entry tool.

Both mechanisms run with the rigor of a production machine learning pipeline. Unlike the memory features built into most AI assistants, which personalize the experience for an individual user, closed-loop learning improves task accuracy for everyone using your organization’s agent. The learning stays scoped to your business process and governed by your tenant.

Inside the research

The approach

Today’s techniques for adapting Large Language Models don’t close the feedback loop between deployment and improvement. Retrieval-augmented generation (RAG) surfaces documents at inference time but doesn’t learn from outcomes. Fine-tuning adapts the model but requires a training and deployment cycle for every update. Open-loop prompt optimization improves a fixed prompt offline but doesn’t incorporate live feedback.

Closed-loop learning closes the gap through two complementary mechanisms. Memory-based optimization captures user corrections as structured memories retrieved at inference time, giving the agent immediate recall. Genetic-Pareto optimization periodically distills those memories into generalized rules using evolutionary prompt optimization, so the agent applies what it’s learned to cases it hasn’t seen. The agent acts, a user corrects, the system learns, the next action improves.

Closed-loop learning builds on two open-source projects. Memory-based optimization takes inspiration from Memento, though our implementation has evolved significantly to fit the Power Apps MCP server’s architecture. Genetic-Pareto optimization is implemented via GEPA, integrated through DSPy, Stanford’s framework for programmatic LLM optimization.

The evaluation

The benchmark had to reflect enterprise data entry in practice. One of our early customers, the UK Electoral Commission, processes thousands of invoices annually from suppliers based in the UK, US, Ireland, and other countries. Each invoice demands structured extraction of supplier name, address, country, and total expenditure, with conventions that vary by supplier country and source document. The corrections the agent must learn are the organization-specific conventions that turn a correct extraction into a usable one.

We evaluated four configurations on a dataset of 100 invoices across 10 independent runs, reporting the average score across runs with 95% confidence intervals. The primary metric is F1 score, balancing precision (are the predictions correct?) with recall (is the model predicting all the expected fields?). Our quality bar is strict: did the user save exactly what the agent predicted, with zero edits? By that measure, a prediction of “UK” when the organization’s records use “United Kingdom” is a quality gap, because the user still had to correct it.

The results

These results are from pre-rollout offline simulation on UK Electoral Commission dataset. The data entry tool extracts content from invoices reliably. The gap is between that raw extraction and the format and conventions the organization expects. Closed-loop learning bridges that gap, calibrating the agent to the business. Across 4277 field instances, closed-loop learning decreased the share of fields users had to edit from 64% to 48%: 1045 fewer fields requiring manual correction.

In 10 independent runs, Genetic-Pareto improved F1 score over the baseline from 66.4% to 74.6%, an 8.2 percentage point improvement.

The optimized prompt outperformed the baseline in all 10 runs, with non-overlapping confidence intervals and a positive confidence interval for the difference.

How Genetic-Pareto calibrated the agent

The F1 number tells part of the story. The baseline typically extracts the right information from the invoice; the gap is in how the business needs that information presented. A supplier name shown as a brand tag rather than the legal entity. An address combined into one line rather than splitting across the fields the organization expects. A total reflecting the ex-VAT amount rather than the gross invoice total.

In one sample run, Genetic-Pareto addressed 76 of 583 gaps in the baseline (a 13% reduction):

These are taste and preference gaps. Genetic-Pareto closes them by calibrating the agent to how the organization structures its data. The gains were most pronounced when specific corrections mapped to a generalized principle. Country accuracy alone jumped from 11% to 78% after Genetic-Pareto learned to expand abbreviated country names. A broader evaluation of additional customers is in progress to validate and expand these findings.

Closing the loop

This evaluation and rollout loop a data science team typically runs happens automatically inside your tenant, through the Power Apps MCP server. The system generates a candidate prompt, runs a shadow experiment (each request uses the current prompt for the user-facing result while the same input is scored in parallel on the candidate), and uses statistical validation (hypothesis testing and power analysis) to decide whether the candidate is measurably better. When it clears the threshold, the candidate automatically becomes the new baseline, and every subsequent request runs on the improved version.

What comes next

Closed-loop learning will extend across more agentic workflows on the Power Apps MCP server over the coming weeks.

The gap between passing the driving test and feeling confident behind the wheel is experience. Closed-loop learning gives agents that experience.

Get started: Add the data entry tool to your agent on the Power Apps MCP server and give your agent a memory.

The post Power Apps MCP server introduces closed-loop learning for enterprise agents appeared first on Microsoft Power Platform Blog.

Here’s what’s new for each persona: 

• For business users, business data in Microsoft 365 Copilot. Your unified business data includes Dynamics 365 or custom apps built in Power Platform powered by Dataverse combined with Microsoft 365 data (i.e. emails, meetings, and documents) to deliver grounded, contextual answers.  

• For makers, business skills describe a specific process. Skills are the detailed steps-by-step instructions involved, the information required, and the business rules that apply. Agents connected to the Dataverse MCP server discover relevant skills automatically and use them to complete tasks according to your organization’s standards.  

• For developers, Dataverse Plugin for coding agents. Dataverse plugin is an open-source plugin that lets AI coding agents like Claude Code and GitHub Copilot build and manage Microsoft Dataverse solutions through natural language. Available on Claude Marketplace: install a plugin, say “connect to Dataverse,” and start building. 

Here’s what we shipped and why it matters. 

Dataverse in Microsoft 365 Copilot

Business data has been locked behind app-specific experiences. Business users context switch between Dynamics 365, Power Apps, Outlook, and Teams to piece together the full picture. What if Copilot could understand your business data the way your best people do? 

That’s now happening. In March, we announced Microsoft 365 Copilot embedded as an in-app sidecar experience within Power Apps, Dynamics 365 Sales, and Dynamics 365 Customer Service. Under the hood, we introduced a reasoning layer natively integrated in Microsoft 365 Copilot, reconciling enterprise data and work signals from across your apps to power the combination of critical sources of business data and insights: Microsoft 365 apps, Dynamics 365 apps, and Power Platform. Coming soon in early June, business data will be available across Microsoft 365 Copilot experiences in Copilot App on desktop, Teams, Outlook, Word, Excel, and PowerPoint.

What does this look like in practice? Ask Microsoft 365 Copilot “There’s new guidance about vendor selection. For overdue issue, please select which vendor to assign” and get a precise list grounded in your CRM records and email signals. No report building. No app switching. No guesswork. Let’s see this in action. 

By leveraging the intelligent semantic layer in Agentic AI powered Dataverse Search, Microsoft 365 Copilot experiences deliver answers using an adaptive reasoning process based on schema and keywords. This allows Microsoft 365 Copilot to understand tables and relationships and how to navigate them to get the right answers rather than doing just keyword search. 

The same proven unified semantic search index that powers global search in Power Apps also provides retrieval and grounding for Copilot, agents, and MCP tools. When your search gets better, every AI experience built on it gets better too. In this release, we’ve made the index faster, more real-time, and easier to manage: 

• Up to 6× faster initialization. Turning on Dataverse search for a new environment now takes minutes, not hours. Your team gets started faster, so they can build more.  
• Near real-time data freshness. Newly added or updated records appear in Copilot results within minutes. Copilot and agents are ground on current business data, not stale snapshots. 
• Zero-disruption schema evolution. Adding or removing columns no longer pauses indexing. Schema changes refresh in the background while Dataverse Search keeps running. 
• Visibility and control for admins. See exactly which tables are indexed, how much capacity each consumes, and download usage reports. Enable or disable indexing for Copilot and search independently, so you can scale AI workloads without impacting existing search behavior. 

One search index for Copilot, agents, and MCP. All grounded in the same governed business data in Dataverse. 

Business skills: teach agents how your organization works 

Your organization’s most valuable knowledge lives as tribal knowledge in people’s heads: the escalation path for a vendor issue, the approval steps for a sales proposal, the process to assign the right specialist to staff your project. Agents can’t access what isn’t simply written down. 

Business skills in Dataverse, now in public preview, captures your processes, policies, and domain expertise as natural-language instructions. Makers can write business skills in plain language or upload existing skills and govern them with built-in controls. The best part: any agent connected to the Dataverse MCP server discovers your skills automatically, whether it runs in Copilot Studio, GitHub Copilot, Azure AI Foundry, or any MCP-compatible client. Define once, apply everywhere – let’s see this in action.  

Velrada makes this real in a field service inspection scenario: 

“Velrada built Inspection Agent to help worksite supervisors and field workers track the maintenance status of their equipment – so they can trust the tools used to get the job done. The Inspection Agent uses business skills to perform an equipment inspection with the user. For an onsite HVAC inspection, the Inspection Agent will invoke the business skill to determine the questions to ask based on equipment class, checks the last inspection outcomes, and pull in context of any historic issues. The result: a conversational assessment that produces a consolidated inspection report on the HVAC unit’s condition and follow-up guidance for maintenance” 

— Matthew Pontel, General Manager of Applied AI, Velrada 

Learn more about business skills: Introducing business skills: Teach agents how your organization works  – Microsoft Power Platform Blog 

Dataverse plugin: coding agents now speak Dataverse 

Enterprise development is shifting from writing code to directing AI agents. Developers describe intent; coding agents orchestrate the right tools over governed business data. What used to require juggling APIs, CLIs, and documentation can now be expressed as a single prompt. 

The Dataverse Plugin for coding agents (in public preview) makes this real. Install one open-source plugin, and your coding agent gets full Dataverse fluency. Under the hood, the plugin packages four tools and knows which one to reach for:  

• Dataverse MCP Servers for ad-hoc discovery and natural-language queries. 

• Dataverse CLI (in preview) for rich data plane actions. 

• Python SDK for batch and scripted operations. 

• PAC CLI for admin gestures like solution export and environment management. 

No manual setup. Describe your intent; the agent handles the orchestration. See this in action. 

Picture this: a platform developer needs to build a customer escalation tracker on Dynamics. With the Dataverse plugin for coding agents, they connect to their environment, create tables, define business skills, configure security roles, and deploy the solution, all through natural language in their coding agent. That’s modern development with coding agents. 

Get started: Install the Dataverse Plugin 

Dataverse agentic evolution: from experimentation to execution 

Six months ago, agents could access your data. Today, they understand your business: your schema, your processes, your rules. The wall between data access and business understanding is coming down: that’s the agent data platform. Today at EU Biz Apps Summit in Cologne, we’re showing all of this live. And we’re just getting started. At //Build in June, we’ll share what’s next. Learn more:  

• Business Skills blog: http://approjects.co.za/?big=en-us/power-platform/blog/2026/05/01/business-skills/ 

• Sample Business Skills on Github: https://github.com/microsoft/dataverse-business-skills

• Dataverse + M365 Copilot blog: Build business understanding with Dataverse in Microsoft 365 Copilot – Microsoft 365 Developer Blog 

• Dataverse docs: https://learn.microsoft.com/en-us/power-apps/maker/data-platform/data-platform-intro 

• Dataverse MCP preview docs: https://learn.microsoft.com/en-us/power-apps/maker/data-platform/data-platform-mcp-preview-tools 

• Dataverse Plugin blog: https://devblogs.microsoft.com/powerplatform/dataverse-plugin-claude-marketplace/ 

• Dataverse Search docs: http://approjects.co.za/?big=en-us/dynamics-365/blog/it-professional/2025/12/08/agentic-ai-dataverse-search/ 

The post Dataverse Is Your Agent Data Platform: Here’s What’s New  appeared first on Microsoft Power Platform Blog.

Business skills: Process knowledge that agents can follow 

Business skills in Dataverse are now in public preview! You can capture your organization’s processes, policies, and domain expertise as natural-language instructions that AI agents discover and follow at runtime. 

Each business skill describes a specific process — the detailed steps-by-step instructions involved, the information required, and the business rules that apply. Agents connected to the Dataverse MCP server discover relevant skills automatically and use them to complete tasks according to your organization’s standards. 

Because skills are defined once and stored centrally in Dataverse, any agent can use them — whether it’s running in Copilot Studio, GitHub Copilot, VS Code, Azure AI Foundry, or any MCP-compatible client. When multiple agents reference the same skill, they follow the same process. Update the skill, and the change applies everywhere — no need to track down and patch individual agent configurations.

Skills are fully governed with built-in sharing and visibility controls, and they’re solution-aware — which means you can add them to your power platform solutions and move them across environments as part of your existing ALM process. 

Seeing it in action 

Previously, asking an agent to follow a multi-step business process — like assigning vendors to open issues — meant the agent had no context for how your team actually handles that work. The result was generic at best and unable to adapt to the changing processes. 

With business skills, the same request produces a precise, grounded result. The agent discovers the relevant business skill, follows your documented process step by step, and completes the task across your Dataverse data — no custom code, no workflow builder, no app switching. 

Create, share, and govern — all from Power Apps 

Business skills live in Dataverse and you can manage them from make.powerapps.com. Write your process in natural language or upload existing documentation, share it with the right people, control who can see and edit it, and deploy it across environments through solutions — all without leaving Power Apps. Update a skill and every connected agent picks up the change immediately, no republishing required.

Prefer to work conversationally? The Dataverse MCP server lets you create and update skills by simply asking an agent. 

Who should use business skills? 

Business skills capture domain specific tasks from existing business workflows as context to further inform Copilot and agents. Whether you’re a maker codifying how your team operates, an agent builder who needs agents to follow real processes instead of generic instructions, or an admin who needs governance over how business knowledge is shared and deployed — business skills are built for you. 

Velrada enables consistent process execution for equipment inspections

Matthew Pontel, General Manager of Applied AI at Velrada remarks that “Velrada built Inspection Agent to help worksite supervisors and field workers track the maintenance status of their equipment – so they can trust the tools used to get the job done.

The Inspection Agent uses business skills to perform an equipment inspection with the user. For an onsite HVAC inspection, the Inspection Agent will invoke the business skill to determine the questions to ask based on equipment class, checks the last inspection outcomes, and pull in context of any historic issues. The result: a conversational assessment that produces a consolidated inspection report on the HVAC unit’s condition and follow-up guidance for maintenance.”

Get started 

Business skills bring your organization’s expertise to every agent — no code, no complex tooling, just your processes written in plain language and available wherever agents run. We invite you to: 

1. Enable Dataverse intelligence in the Power Platform admin center. 

2. Navigate to the  Business skills page in Power Apps from the left pane. 

3. Create your first skill or upload an existing skill. 

4. Connect an agent to the Dataverse MCP server and see it in action. 

Want a head start? The sample business skills repository on GitHub includes production-ready examples you can install directly in your environment. 

Try the preview today — we can’t wait to see what you build. Learn more with additional resources: 

• What is Dataverse intelligence? 

• Business skills overview 

• Create and use business skills 

• Sample business skills on GitHub 

The post Introducing business skills: Teach agents how your organization works  appeared first on Microsoft Power Platform Blog.

In my recent conversation with Keith Kirkpatrick, President and Research Director with Futurum Group, we spent less time talking about how quickly agents can act—and more time talking about who stays in control, how work actually gets done, and why intelligent apps matter more than ever. 

The future of work isn’t about humans racing to keep up with machines. It’s about humans stepping into higher-value roles—guiding, shaping, and supervising intelligent systems that operate at scale.

Intelligent apps change the role of the human

As agents become more capable, the role of the business user changes. People keep working—but they do less manual work. 

Humans are increasingly moving away from step-by-step processes to designing the flow, defining the rules, and deciding where judgment matters in their workflows. Intelligent apps become the place where all that happens. Apps are evolving, becoming intelligent, adaptive operating surfaces where people and agents work together. 

That’s an important shift. Agents are not replacing apps. Agents and apps are working together. Agents now show up inside apps, embedded in places where work already happens, with the right context, data, and governance. 

Human-in-the-loop isn’t a checkbox, it’s an imperative 

One of the most practical questions Keith raised was about control: How do organizations decide what agents can do on their own—and when humans need to step in? 

The answer is design. 

Take something like processing a request for proposal (RFP) or an insurance claim. An organization might decide that transactions under a certain threshold proceed automatically, while higher-risk cases require review. That decision goes beyond technical limits. It reflects business risk, regulatory requirements, and confidence in the process. 

The important part is this: those boundaries are intentional, adjustable, and visible. You don’t hardcode them once and walk away. You refine them as conditions change and as confidence grows. 

That’s what human-in-the-loop really means: putting judgment where it matters most. 

Automation works best when agents specialize 

Another theme we discussed was scale. As organizations move beyond single workflows, they quickly discover that one giant “do-everything” agent doesn’t hold up, and is likely not the optimal path for impact and scale.  

What does scale is multiagent orchestration. Instead of building one monolithic agent, teams break processes into smaller, specialized agents—each responsible for a specific function. One agent validates data. Another checks records. Another recommends an outcome. Humans oversee the system. 

This approach has two benefits. First, it’s more resilient. If something changes, you update one part instead of everything. Second, it creates reuse. An agent built for one process can often support others. 

That’s how automation compounds. Apps, agents, and chat each have a role. Automation works best when you match the right tool to the right task. A mobile app with a barcode scanner is faster when speed matters. A background agent is better when no interaction is needed. And chat earns its place when collaboration, clarification, or exploration is involved. Apps, agents, and chat each have a role, the key is to leverage each option where it makes the most sense. 

When these apps, chat and agents work together, work feels simpler—not more complex. This shift creates new opportunities for people. One of the most overlooked impacts of agentic automation is inclusion. 

When systems can summarize meetings, surface the right information at the right time, and reduce cognitive load, more people can contribute effectively—regardless of working style. For example, meeting transcripts can allow participants to stay fully focused on the discussion, knowing the notes will be available after the meeting. Intelligent assistance doesn’t just increase productivity. It lowers barriers. 

That matters. Not as a side benefit, but as a core outcome of better system design. You don’t plan your way into this—you learn by doing.  

The advice I keep giving customers is straightforward: Start deliberately

You can’t whiteboard every scenario. You can’t predict every edge case. You learn by deploying, observing, adjusting, and scaling—with governance in place from the beginning. 

The organizations that move fastest aren’t reckless. They’re deliberate. They build intelligent apps with clear boundaries, visibility, and accountability—and they evolve from there. 

This shift is already underway. The question isn’t whether intelligent apps and agents will change how work gets done. It’s whether you’ll design for that change—or react to it later. 

If you want to go deeper into how organizations are putting these ideas into practice and to hear how they are making deliberate choices about when to automate, or assist, or hand things back to people, I encourage you to watch my full conversation with Keith Kirkpatrick. We cover real examples, design choices, and what leaders should be thinking about next. I invite you to explore how intelligent apps, agents, and human judgment come together at work and what this could mean for your team. 

The post Intelligent apps, human leadership, and the new shape of work  appeared first on Microsoft Power Platform Blog.

Meet /add-server-logic, /add-cloud-flow, and /integrate-backend – three skills that complete the application stack. They build on an already working site by introducing secure server-side logic, Power Automate cloud flows, and intelligent backend orchestration for end-to-end functionality.

What’s new

• /add-server-logic generates secure server-side JavaScript endpoints for validation, secret management, external API calls, and cross-entity operations.
• /add-cloud-flow integrates existing Power Automate cloud flows into your Power Pages site for approval workflows, notifications, and scheduled automation.
• /integrate-backend analyzes your prototype, determines the right approach (Web API, Server Logic, and/or cloud flow) for each feature, and orchestrates the complete build sequence.

/add-server-logic: secure server-side endpoints, generated end to end

Server Logic in Power Pages moves critical operations from the browser to the server for improved control, scalability, and security. It’s generally available, so it’s fully supported for production workloads. With server logic, your site can perform complex tasks and integrations without exposing sensitive logic or data on the client side. Server logic enables you to:

• Connect to external services. Integrate securely with REST APIs, Azure Functions, or other business systems, e.g., call the Stripe API to process a payment without exposing your API key. (Tutorial: interact with external services)
• Perform secure data operations. Query, update, or delete Dataverse records with consistent server-side validation, e.g., check inventory levels before accepting an order submission. (Tutorial: interact with Dataverse tables)
• Run custom logic. Calculate totals, enforce business rules, or enrich data with external lookups before returning results, e.g., aggregate data across multiple tables into a single global search response.
• Manage secrets server-side. Store credentials and API keys on the server, never in client code, e.g., authenticate with Microsoft Graph to upload documents to SharePoint. (Tutorial: interact with Microsoft Graph and SharePoint)

The /add-server-logic allows you to describe what you need in plain language, and it generates the server-side endpoint, web role assignments, table permissions, a typed client-side service, and component updates.

Here’s an example. Say your order form needs to validate inventory before accepting a submission:

You: "/add-server-logic Add validation that rejects orders when quantity exceeds inventory"

Plugin:
        → Creates server-logic/validate-order.js (server-side endpoint)
        → Assigns Authenticated Users web role
        → Verifies table permissions for cr_inventories
        → Creates src/services/serverLogic/validateOrder.ts (typed client)
        → Updates OrderForm.tsx to call validateOrder() before submit

Or say your site needs a global search that queries across multiple Dataverse tables (products, orders, and knowledge articles) and returns unified results. That kind of cross-entity aggregation can’t run from the browser in a single call:

You: "/add-server-logic Add a global search endpoint that searches across products,
      orders, and knowledge articles and returns combined results"

Plugin: 
        → Creates server-logic/global-search.js (server-side endpoint)
        → Queries cr_products, cr_orders, and cr_knowledge_articles
        → Aggregates and ranks results server-side
        → Assigns Authenticated Users web role
        → Verifies table permissions for all three tables (Read)
        → Creates src/services/serverLogic/globalSearch.ts (typed client)
        → Updates SearchPage.tsx to call globalSearch() on input

Before generating any code, a built-in Server Logic Architect agent analyzes your use case and presents a proposal for your review.

/add-cloud-flow: Power Automate integration from your site

Not everything belongs in a server-side endpoint. Approval workflows, email notifications, and event-driven automation are better suited to Power Automate cloud flows. The /add-cloud-flow skill integrates an existing cloud flow into your Power Pages site. It does not create new cloud flows. You build the flow in Power Automate, and the skill handles the integration: registering the flow with your site, generating the client-side code to trigger it, and wiring up data exchange between the page and the flow.

You: "/add-cloud-flow Connect the supplier approval flow to my application page"

Plugin: 
        → Registers the existing cloud flow with your site
        → Generates client-side code to trigger the flow
        → Handles async workflow state and callback patterns

Whether it’s a manager approval step, an order confirmation email, or a nightly data sync, /add-cloud-flow handles the integration so you focus on the business process.

/integrate-backend: let AI choose the right approach

Start here if you’re not sure whether a feature needs Web API, Server Logic, or a cloud flow. /integrate-backend acts as your server-side architect. It analyzes your website, determines the right approach for each feature, and orchestrates the plugin skills to build everything in the correct order.

Take a supplier portal with product listings, order submission, a global search across products and orders, and an invoice approval workflow. Without /integrate-backend, you’d need to figure out that product listings are standard CRUD (Web API), global search requires cross-entity aggregation on the server (Server Logic), and invoice approvals need a multi-step flow (Power Automate). You’d also need to sequence the work: Dataverse tables before Web API, web roles before Server Logic, authentication before server-side endpoints.

The /integrate-backend skill automatically scans your entire website and recommends relevant business processes.

You: /integrate-backend

Plugin:
  ANALYSIS
  ════════
  #   Feature              Approach         Reason
  1   Product listings     Web API          Standard CRUD on cr_products
  2   Order submission     Server Logic     Inventory validation + transaction
  3   Global search        Server Logic     Cross-entity aggregation on server
  4   Invoice approvals    Cloud Flow       Multi-step approval workflow

How it works

Every skill follows a propose-then-build workflow. An AI architect agent analyzes your request, designs the solution, and presents it for approval. No code is generated, and no infrastructure is created until you approve. This keeps you in control while eliminating manual configuration.

The decision framework is simple:

• Server Logic. Secrets or API keys, server-side validation, multi-table transactions, external or on-premises service calls, cross-entity search, rate limiting, or Dataverse plugin invocation.
• Cloud flow. Approval workflows, notifications, or scheduled processing.
• Web API. Everything else (standard CRUD operations).

Benefits

• Enhanced security. Business logic, secrets, and API keys stay on the server and are never exposed in the browser.
• Reduced manual configuration. Each skill generates endpoints, permissions, typed services, and component updates end to end.
• Intelligent approach selection. /integrate-backend determines whether each feature needs Web API, Server Logic, or a cloud flow, so you don’t have to.

Get started

Install or update the plugin and PAC CLI

Install the latest plugin and PAC CLI, as both are required. Server logic support was introduced in the latest PAC CLI release, so older versions will not work with /add-server-logic. For the easiest setup, use Quick Install (recommended), which installs all Power Platform plugins, updates PAC CLI, and enables auto-update.

Get started with the Power Pages plugin for GitHub Copilot CLI and Claude Code.

We are looking for your feedback

Your feedback helps us improve the developer experience on Power Pages. Share your thoughts and reach out on the Power Pages Community Forum. You can also submit ideas through the Power Pages Ideas portal.

The post Build your server-side logic with AI: new Power Pages Agentic Code skills appeared first on Microsoft Power Platform Blog.

Here’s what’s new:

• Microsoft 365 Copilot is now generally available in model-driven apps and in public preview for canvas apps, bringing the full intelligence of Copilot into the flow of business processes.
• New app skills including data entry, exploration, visualization, and summarization are now generally available in Power Apps. App-based form and grid experiences in Copilot Chat will be generally available in July 2026, with support for custom UX entering preview.
• Agent feed with Power Apps MCP Server will be generally available on May 4, 2026, giving users a dedicated experience to supervise agent activity directly inside their business apps.

Each of these advancements aims at making AI useful where work actually happens. What sets this release apart is its interoperability: agents and Copilot are embedded directly within apps to boost productivity, while app capabilities are infused into agents to ground AI in real context and help make it more reliable and trustworthy.

Embedding Microsoft 365 Copilot directly within apps

The biggest productivity gains from AI come not from separate tools, but from embedding it inside the app where someone is already working, where the data model, business rules, and user context are all present.

Today, as users fill out a form, the app can convert emails or documents into structured fields automatically, with a review step before anything is saved. Natural-language search lets users simply ask, “show me open high-priority tickets this week,” instantly reshaping the view. AI-generated summaries distill long activity histories in seconds.

But this is just the starting point. With Microsoft 365 Copilot now generally available in model-driven apps, users gain something broader: the ability to ask questions and get answers grounded not just in the records on screen, but across the full breadth of business and productivity data through Microsoft Work IQ. The Copilot experience respects the same security, permissions, and business logic the app already enforces. Admins enable it at the tenant level. Makers configure it in a few clicks. The same app is now meaningfully more productive.

Bringing app skills to agents

New app skills including data entry, exploration, visualization, and summarization are now generally available in Power Apps. But the value of a business application doesn’t stop at its own UI.

Using an app’s MCP server, these app skills—starting with structured form and grid views—can now be exposed as reusable tools for agents in public preview, with additional custom UX skills coming soon. This extends app productivity beyond the app itself to AI surfaces such as Copilot, custom agents, and automations.

This is where the two‑way relationship between apps and agents becomes tangible. In the previous section, AI and Copilot came into the app to help users work faster. Here, the app’s capabilities flow outward into agents and Copilot. For example, a recruiting app that has accumulated years of hiring policy can now power an agent that accesses the same records, enforces the same rules, and operates under the same controls. As organizations digitize more processes, their agents become more capable.

Human oversight where it matters most through the agent feed

As agents execute more tasks, the question is how to keep humans in the loop at the right moments. The agent feed in model-driven apps, generally available in May 2026, answers that directly.

It gives business users a dedicated space to see, review, and guide agent activity as it happens and within the app, not in a separate monitoring tool. Makers control the approval threshold: low-risk actions complete quietly in the background; higher-impact actions like sending emails surface as explicit approvals. Side-by-side comparisons, deep links to records, and performance signals make oversight practical.

An insurance claims team, for example, uses an agent that extracts data from incoming emails and prepopulates case forms. Adjusters review and approve in the agent feed before anything enters the system. Humans oversee. Agents execute. Work gets done.

Turning AI from experimentation to execution

From embedding intelligence directly in apps, to extending app capabilities across AI surfaces like Copilot and custom agents, to empowering seamless human-AI collaboration through the agent feed, every component is connected. Together, this answers the question business and IT leaders are asking: how to bring AI into core business processes with real impact, without starting from scratch. This is what makes the shift from experimentation to execution real for the enterprise.

Watch the Business Applications Update event for product demos that show how apps, agents, and Microsoft 365 Copilot drive business transformation.

The post Making business apps smarter with AI, Copilot, and agents in Power Apps appeared first on Microsoft Power Platform Blog.