Microsoft Power Platform Blog

What’s new in Power Platform: May 2026 feature update

Tiffany Treacy — Thu, 14 May 2026 18:16:52 +0000

Summary Welcome to the Power Platform monthly feature update! We will use this blog to share news in Power Platform from the last month, so you can find a summary of product, community, and learning updates from Power Platform in one easy place. Now, let’s dive into what’s new in Power Platform:

Get started with the latest updates today!

Jump into Power Apps, Power Automate, and Power Pages to try the latest updates, you can use an existing environment or get started for free using the Developer plan.

Power Apps

Generally available: Power Fx user defined types (UDTs)

User defined types (UDTs) are now generally available, as of version 3.26044. They are enabled for all new apps and can be enabled for existing apps through settings > updates > new > user-defined types. UDTs are defined with the Type function in the App.Formulas property.

UDTs enable user defined functions (UDFs) to pass complex data structures in and out of your own functions such as records and tables. For example, with the UDT definition Point := Type( { x: Number, y: Number } ); and UDF definition Distance( to: Point, from: Point ) : Number = Sqrt( (to.x – from.x)^2 + (to.y – from.y)^2 );, the formula Distance( {x:0,y:0}, {x:3,y:4} ) returns 5.

UDTs also enable the strong typing of JSON with the ParseJSON function, providing basic data type validation and simplifying coercions. For example, with the UDT definition Person := Type( { Name: Text, Birthday: Date } ); the formula ParseJSON( “{ “”Name””: “”Fred””, “”Birthday””: “”2001-01-01”” }”, Person ) will validate that the birthday is in the proper format and will convert to a Power Fx strongly type date, allowing date functions such as Weekday to be used (for this example, correctly returning 2).

Learn more

Agentic apps

Public preview: custom tools and rich UI for app-based conversations

We’re introducing custom tools and rich UI for app‑based conversations in Power Apps, now in public preview, building on the broader April 2026 updates to Microsoft Power Platform. This release extends how model‑driven apps integrate with Microsoft 365 Copilot, enabling more contextual, visual, and action‑driven experiences that move beyond basic data access toward collaborative workflows inside Copilot.

With this capability, makers can now define custom MCP-powered tools that bring app-specific business logic into Copilot, alongside interactive, Fluent‑based UI widgets that present insights and guide next steps. These components integrate directly into the app’s MCP server and declarative agent, allowing Copilot to dynamically orchestrate actions, combine data, and deliver richer, more guided experiences — all through natural language interactions.

Learn more

AI powered development

Input support for generative pages

Generative pages can now accept context passed in as input, so a page can open already aware of the record the user is working with or any other custom data your scenario needs. That single change unlocks a much broader set of places generative pages can live inside a model-driven app.

Until now, generative pages were primarily limited to standalone, top-level experiences off the sitemap. With input support, you can now launch a generative page from a command bar button, a grid row action, a sub grid navigation, or any other in-app entry point, and the page receives the record context it needs to render the right view.

A few scenarios are still on the way: opening generative pages in side panes, and adding them as tabs or sections within forms via the form designer. We’re working on those for the next quarter.

Other notable improvements

Add an existing generative page to an app: The ‘add a page’ flyout now lets makers pick an existing generative page from the environment instead of always creating a new one, making it easy to reuse a page across multiple apps.
Generative pages in the Power Apps mobile app: Generative pages now display as expected in the Power Apps mobile app. Offline support is not yet available.
Code diff across sessions: The code diff view now works correctly when resuming an editing session, giving makers a continuous view of how a page has evolved across multiple sittings.

Learn more

Migrate your InfoPath forms to Power Platform with coding agents

For years, InfoPath has powered business-critical forms across organizations. With InfoPath now retired, makers face the challenge of opening each .xsn, mapping every control, rewiring every data connection, and recreating every rule by hand.

With the Canvas Authoring MCP Server and the PowerCAT Skill for InfoPath Migration, makers can now use their preferred AI coding agents – GitHub Copilot, Claude Code, or any MCP-compatible assistant – to migrate InfoPath forms into Power Apps Canvas Apps through natural conversation.

The PowerCAT InfoPath Migration Skill teaches your coding agent how to read and interpret InfoPath artifacts. It unpacks the .xsn cabinet, parses the underlying XSN/XSF/XSD definitions, and produces a structured intermediate representation of the form: views, fields, data sources, rules, validations, and submit behaviours. The Canvas Authoring MCP Server then creates appropriate controls, sets properties and formulas, inspects SharePoint lists chosen as the new backing store, and emits structured, validated YAML for each screen. The maker can also continue editing and publishing the app from the Power Apps studio.

Learn more

Building modern apps

Modern control updates for Button, Slider, Icon, and Dropdown with Icon now supporting OnSelect

The modern Button, Slider, Icon, and Dropdown controls are now GA-quality, with focused improvements based on maker feedback. The headline change is OnSelect on the Icon control, one of the most-requested capabilities on modern icon, letting an icon directly trigger actions without overlaying a transparent button. Icons set with OnSelect now render with proper button semantics, including keyboard and screen reader accessibility.

The Dropdown control on desktop now opens a Fluent-themed flyout that matches your app’s visual theme, replacing the browser’s native picker for web. Button and Slider received border, padding, and font property parity with other modern controls. The Slider handle and track render cleanly at all sizes, and Button hover, pressed, and disabled states are visually consistent.

One-click updates on old controls are yet to roll out.

Learn more

Generally available: Grid container with drag-and-drop authoring and full undo/redo

The Grid container control is now generally available. Grid container is the modern, CSS grid–style layout container that replaces heavy X/Y absolute positioning. Makers can define rows and columns and place child controls using Row Start/End and Column Start/End, with span support. This eliminates most container nesting and the formulas previously needed to make canvas layouts responsive.

The GA release includes major authoring improvements shipped over the last several weeks. Makers can now drag controls directly into grid cells, resize controls using span handles, and rely on full undo/redo support for both drag and resize actions. Controls can also overlap temporarily during repositioning, removing the previous forced delete-and-read workflow. Scroll-aware hit-testing means drag interactions work correctly even when the grid scrolls.

Learn more

Public preview: New Data Grid control – a Fluent UI based grid with search, sort, and multi-select for high-density data

The new Data Grid modern control enters public preview as a high-performance, data-dense view for tabular data. Built on Fluent UI, Data Grid supports searchable rows (with a built-in search bar above the grid and a SearchText output property), sortable columns, multi-row selection, and configurable column sub-controls including Text, Number, Phone, Email, URL, and Button column types. Columns are added automatically when you connect a data source, and properties can be unlocked for per-column customization.

Known preview limitations: attachment-type columns from Dataverse are not yet supported, and row virtualization for large datasets is not yet available. Both are planned and coming in the next few weeks.

Learn more

Learning updates

Training paths and labs

Updated training

Power Apps maker

New

Updated

Power Automate

New

Self-healing (preview)

Updated

Power Pages

New

Updated

Power Platform administration

New

Updated

Power Platform developer

New

Updated

Power Platform connectors

Updated

Authenticate your API and connector with Microsoft Entra ID

The post What’s new in Power Platform: May 2026 feature update appeared first on Microsoft Power Platform Blog.

Power Fx: User Defined Types Generally Available

Greg Lindhorst — Wed, 13 May 2026 18:59:00 +0000

User Defined Types (UDTs) are now generally available!

As of Power Apps Studio version 3.26044, UDTs are enabled by default for new apps and can be enabled for existing apps under Settings > Updates > New > User-Defined types.

Enhanced Component Properties, User Defined Functions, and now User Defined Types have all reached general availability and are ready for your production workloads. You now have powerful tools for breaking large, mission critical apps into more modular, error resistant, and maintainable parts.

Records and Tables as parameters and return values

User defined types(UDTs) help make your formulas easier to write and understand by bundling information that logically belongs together into data structures. It also helps your formulas be less error prone by strongly typing information, especially useful when working with JSON.

For example, bundled information on a Book, such as the title, the author, the page count, and the publication year can be grouped together with appropriate types for each element using the Type function in the App object’s Formulas property:

Book := Type( { Title: Text, Author: Text, Pages: Number, Published: Date } );

A book can be passed into a User defined function to be stored in a database:

AddBook( newBook: Book ) : Void = { Collect( Library, newBook ) };

And a table of Books can be returned from a User defined function that filters on page count:

Books := Type( [ Book ] );

FastReads(): Books = Filter( Library, Pages < 20 );

UDTs and JSON

UDTs can be very helpful when working with JSON by validating and converting untyped text into a typed Power F object. For example, JSON has no date/time data type, instead it is stored in a string, often in ISO 8601 format. By providing a UDT, ParseJSON knows it needs to convert the string containing “1902-03-25” into a proper Date value, required by the record passed to AddBook():

AddBook( ParseJSON( "{ ""Title"": ""Hound of the Baskervilles"", ""Published"": ""1902-03-25"" }", Book ) )

If instead, we give ParseJSON a value that it can’t convert, say “03/25/1902” instead, it will generate an error:

AddBook( ParseJSON( "{ ""Title"": ""Hound of the Baskervilles"", ""Published"": ""03/25/1902"" }", Book ) )

Error: Expected value ’03/25/1902′ to be a valid RFC 3339 ‘full-date’ or ‘date-time’ format. Allowed ISO 8601 format(s): ‘YYYY-MM-DD’ …

IsType and AsType

If you’d like finer control over the conversion to a strongly typed value, to first detect and avoid the error, use the IsType and AsType functions. IsType can determine if a Dynamic value is of a particular type without producing an error. For example:

ForAll( ParseJSON( "[ { ""Published"": ""03/25/1902"" }, { ""Published"": ""1902-03-25"" } ]" ), If( IsType( ThisRecord, Book ), AsType( ThisRecord, Book ), Blank() ) )

results in this table, where the missing columns of the valid Book record are filled in with Blank() values:

[ Blank(), { Published:Date(1902,3,25), Title:Blank(), Author:Blank(), Pages:Blank() } ]

RecordOf

Finally, sometimes you have the definition for a table of items, and wish to define a function that takes one of those items as an argument. For example, had we started with the definition of Books (plural):

Books := Type( [ // defines a single column table { // defines a record Title: Text, Author: Text, Pages: Number, Published: Date } ] );

We can define the type for a single book as:

Book := Type( RecordOf( Books ) );

Exactly as we did above, we can use this Book type to define our AddBook function. The definitions of Book and Books here is identical to what we did before – here we started with Books (plural) and above we started with Book (singular).

Let’s go!

Now that UDTs and UDFs are generally available, you can use them with confidence in production workloads. Use them to simplify your formulas and make them more error resistant, especially when working with JSON.

To recap, UDTs are created in the App object’s Formulas property with the Type and RecordOf functions. They are used in UDF definitions (also in App.Formulas) and with the ParseJSON, AsType, and IsType functions.

We’d love your feedback on the Microsoft Power Platform Community Forum where you can also find answers to your questions.

We can’t wait to see what you create!

The post Power Fx: User Defined Types Generally Available appeared first on Microsoft Power Platform Blog.

Power Apps MCP server introduces closed-loop learning for enterprise agents

Srihari Srinivasa — Tue, 12 May 2026 16:00:00 +0000

Enterprise AI has made building agents faster than ever. But teaching those agents how your organization works still means feeding knowledge in as documents and custom instructions or standing up a data science team to run the training, evaluation, and optimization cycles yourself. For IT leaders running agents at scale, that’s a ceiling on how much institutional knowledge your systems can hold, and an overhead that grows with every agent you add.

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.

Before: The agent extracts “UK” as written. The user corrects it to “United Kingdom” in the Agent feed.

After: A new invoice shows “USA”. The agent automatically expands it to “United States of America” — a pattern it learned from prior corrections, applied to a country it hasn’t seen corrected before.

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.

	Personalization	Closed-loop learning
Purpose	Tailor experience	Improve accuracy
Source	User preferences	Corrections from usage
Scope	Individual user	Organization-wide
Impact	Agent feels natural	Agent produces fewer errors
Example	“Call me Sarah”	“Expand abbreviated country names to full standard form”

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.

Closed-loop learning calibrates the agent to the UK Electoral Commission’s invoice conventions, lifting F1 extraction accuracy by 8.2 percentage points over the baseline across 10 independent runs.

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

Field category	Gaps addressed	What Genetic-Pareto learned
Addresses	59	UK formatting heuristics: town + postcode splitting, Scottish or island locality handling, supplier-only address extraction
Total Expenditure	12	Use gross invoice total (including VAT), sum multiple invoices from same supplier, ignore partial amounts
Supplier Names	5	Use legal entity name from invoice header, not brand tags, remittance agents, or “Bill To” sections

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.

Agentic Administration: Dataverse Admin Skills now available in Public Preview

Anirudha Bakore — Tue, 12 May 2026 15:33:42 +0000

Dataverse Admin Skills (dv-admin) lets Power Platform admins use natural language to manage Dataverse environments at scale. No more clicking through Power Platform admin center (PPAC), no more repetitive tasks across 50 environments.

The Problem with Agentic Administration Today

You’re managing 20 Dataverse environments. A security team asks you to enforce settings everywhere. You open the Power Platform admin center, click through the environment list, enter settings for each one, repeat 20 times. Or you wait for a script engineer to define a bulk delete flow for stale records. Hours of work that a computer should have done in seconds.

That gap between intent and execution is where agentic administration lives. And it’s now available.

What is Dataverse Admin Skills?

Dataverse Admin Skills brings Dataverse environment administration into your coding tool through two paths:

Primary path: Agentic (natural language). You describe what you want in plain English. The Dataverse Skills Plugin (which includes dv-admin, dv-data, dv-query, dv-metadata, dv-solution, and more) runs inside Claude Code or GitHub Copilot. It translates your intent into the right PAC CLI commands (pac org, pac data, pac admin, pac auth), executes them against the Dataverse Web API, and handles everything from org settings and OrgDB toggles to bulk delete, retention, recycle bin, and security. The plugin enforces a 37-toggle Power Platform admin center (PPAC) allowlist and built-in safety guardrails, including confirmation prompts and multi-environment parallel execution.
Optional path: Direct scripting. The same PAC CLI commands that power the agentic path are available for Bash, PowerShell, or SDK scripts. Use this for CI/CD pipelines, runbooks, or any automation where you want repeatable, programmatic control.

Both paths hit the same trusted PAC CLI (v2.6+, .NET Framework) and Dataverse Web API. The agentic path adds natural language understanding, multi-environment discovery, and safety checks on top.

Try this Prompt: “Enable AllowMCP setting on all environments starting with Preprod”

The agent responds:

Lists your Dataverse environments

Filters for environments starting with “Preprod”

Asks you to confirm the list

Updates each environment in parallel

Shows you a summary table of what changed

One sentence. No browser tabs. No scripts to write.

What’s Available Now and Coming Soon

Settings Management. Read and update 37 allowlisted Power Platform admin center (PPAC) toggles across environments: MCP, audit, retention, recycle bin, search, Fabric, security, and more. Single environment or bulk, with parallel execution.
Bulk Delete. Schedule, list, pause, resume, and cancel bulk delete jobs. Built-in safety: confirmation prompts before destructive operations, FetchXML validation, and system table warnings.
Long-Term Retention. Enable retention on entities, define archival criteria with FetchXML, and monitor retention jobs. Move old records to long-term storage without permanently deleting them, ideal for compliance scenarios.
Capacity Management (coming soon): storage breakdowns, growth trends, capacity alerts, and archival recommendations, all from your coding tool. We’ll share these scenarios as they become available.

Get Started and Try it out in three simple steps

Step 1: Install the plugin

GitHub Copilot (VS Code):

 /plugin install dataverse@awesome-copilot

Claude Code:

/plugin install dataverse@claude-plugins-official

Step 2: Try it

Open your coding tool and ask:
List all my Dataverse environments
The agent will install PAC CLI if needed, authenticate you, and return your environments. If anything is missing, it walks you through it.

Step 3: Test the scenarios

Settings management:

“Is auditing enabled on my dev environment?”

“Enable auditing on all my developer environments”

“Show me plugin trace log settings across all my environments”

Bulk delete:

“Delete all email records created before January 1, 2024”

“Show me all bulk delete jobs on my environment”

“Pause the bulk delete job with ID …”

This is the initial public preview release. We are continuously refining and expanding skills, so keep checking for updates. Learn more:

Dataverse Plugin in Claude Marketplace Blog: Dataverse Plugin Is Now on the Claude Marketplace | Power Platform Developer Blog
Dataverse Skills Blog: Dataverse Skills: Your Coding Agent Now Speaks Dataverse | Power Platform Developer Blog
Dataverse Skills GitHub: Eight Dataverse Skills available today

The post Agentic Administration: Dataverse Admin Skills now available in Public Preview appeared first on Microsoft Power Platform Blog.

Dataverse Is Your Agent Data Platform: Here’s What’s New

Julie Koesmarno — Tue, 05 May 2026 16:30:00 +0000

Every organization building AI agents hits the same wall. Agents can access data, but they can’t understand the business. They retrieve records but miss context. They answer questions but don’t know your rules, your relationships, your processes. The bottleneck is no longer model access. It’s business context. Over the past six months, we’ve been building Microsoft Dataverse into the agent data platform: the layer that gives agents not just data access, but real business understanding.

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.

Introducing business skills: Teach agents how your organization works

Prithvi Khosla — Fri, 01 May 2026 18:05:46 +0000

Every organization has processes that live in people’s heads — the steps to qualify a lead, the rules for approving a discount, the checklist for onboarding a new vendor. This undocumented institutional knowledge drives consistent outcomes when experienced employees follow it, but it’s never been available to AI agents. Until now.

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.

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:

Enable Dataverse intelligence in the Power Platform admin center.

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

Create your first skill or upload an existing skill.

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.

From Ideas to Impact: How Frontier Firms scale agents with confidence

Michelle Lancaster — Mon, 27 Apr 2026 15:00:00 +0000

In a recent conversation I had with Futurum Vice President and Software Lifecycle Engineering Practice Lead, Mitch Ashley, we talked about a pattern we’re seeing again and again with customers that are exploring agents.

Most organizations can easily identify dozens—or hundreds—of potential agentic use cases. The challenge they often face is determining how to move from their long list of options to real solutions that drive meaningful business impact, without stalling in pilot mode or creating risk along the way.

The organizations I see getting real traction—what we at Microsoft call Frontier Firms—start in a very specific place.

Drive innovation across your business with Microsoft Power Platform

Start with workflows, not agents

Successful teams begin by asking, “Which workflows matter most to the business?”

Apps already encode how work gets done. They reflect real processes, real users, and real governance. That makes them the right foundation. When you introduce agents into existing applications and workflows, you’re building on sound, existing structures: security models, data access, ownership, and accountability.

This is why we consistently see better outcomes when customers start their agentic transformation with solutions they’ve already created using Power Apps and then layering in agents. Those companies are benefitting from all the hard work they’ve done defining roles, permissions, and end‑to‑end flows. Agents are how they extend those investments, building on their existing, strong foundation.

Vision needs a roadmap

Many organizations have a strong agentic vision. Fewer have a clear path to execution.

Some teams invest heavily in governance and controls, but these same teams can struggle to show early returns. Others build a compelling proof of concept, then hit friction when they try to scale it across a department or function.

The teams that break through are very deliberate about outcomes. They decide which parts of a workflow are well suited to agents, where human judgment still matters, and how those pieces connect. They focus on completing a workflow, not automating isolated steps.

Customer relationship management (CRM) is a good example. With a CRM solution, there is opportunity in identifying where agents can handle research, triage, or preparation, while humans deliver maximum value by staying focused on decisions, relationships, and outcomes.

Adoption is a capability, not an event

One of the biggest misconceptions about agents is that adoption will take care of itself. That’s not what we see in practice.

People need clarity about what an agent does, where it adds value, and how it fits into their daily work. Using agents effectively is a skill that develops over time. Learning and successful adoption require guidance, repetition, and reinforcement.

The organizations that scale successfully treat adoption as a shared muscle. Managers become power users. Learning becomes social. Teams run prompt‑a‑thons, share examples, and compare what’s working. The momentum that creates matters more than any single feature.

Unlock AI agent adoption today

Security and governance enable speed

Governance is often framed as a constraint. In reality, it’s what allows teams to move faster with confidence.

As agents become more capable, managing access, intent, and oversight becomes critical. A single compromised identity can expose far more than intended if guardrails aren’t in place.

That risk is a driver for customers to establish agentic centers of excellence early. These teams focus on ideation, governance, and scale together. Once guardrails are clearly defined and in place, we see teams spending less time debating risk and more time delivering value to the business.

Focus on value, then scale deliberately

One thing I’ve seen in Frontier Firms is that they are realistic about their journey. They are generally starting small, proving the value of an agentic transformation, and then connecting additional workflows over time.

As I shared with Mitch, the strong first use cases I’ve seen are those that are repetitive, meaningful, and measurable. When a solution reduces friction for employees or customers and creates visible impact it’s often an indicator of an optimal workflow. With that initial success, it becomes much easier to extend the model across adjacent scenarios.

This approach helps customers avoid what you might call ‘pilot purgatory.’ Successful pilots don’t stay pilots. They become solutions that spread across a business because people ask for them.

Measure what actually matters

Just counting agents isn’t enough though. Real measurement of success looks at sustained usage, employee experience, and customer outcomes alongside efficiency.

As I shared with Mitch, at Microsoft, we’ve proven AI-powered success firsthand in our customer service teams. With the same number of people, we’re handling roughly twice the volume of customer cases. We’ve seen our customer satisfaction improve. And, our employees can now spend more time solving problems instead of answering the same questions repeatedly.

That combination—efficiency, experience, and capacity for innovation—is the signal we have that transformation is real.

What separates leaders from the rest

The organizations leading with agents today share a few traits. They start with workflows. They invest in governance early. They treat adoption as a capability. And they stay focused on business value, not novelty.

Agents don’t replace people. They change where people spend their time and energy. The companies that understand that are building a foundation that will serve them well as this technology continues to evolve.

Watch my full conversation with Mitch Ashley to hear more about how organizations are moving from ideas to impact and what Frontier Firms are doing differently to drive successful agentic transformations.

Build solutions with low-code tools from Microsoft Power Platform

The post From Ideas to Impact: How Frontier Firms scale agents with confidence appeared first on Microsoft Power Platform Blog.

More Secure SharePoint Integration in Power Pages with Site‑Scoped Permissions

Nagesh Bhat — Thu, 23 Apr 2026 13:25:07 +0000

Strong security and governance are essential for any external-facing web presence. Power Pages now strengthens this with enhanced SharePoint permission management shifting from broad site collection access to precise, site-level controls.

Key improvements

Site-level scoping instead of site collection wide access
Reduced exposure of unrelated SharePoint content
Stronger alignment with least-privilege security principles

This change ensures that Power Pages site only has access to the SharePoint resources it truly needs nothing more.

No change to Admin experience or configuration flow

The existing setup experience for SharePoint document management remains consistent, including:

Enabling document management for the environment
Configuring SharePoint integration in the Power Platform admin centre
Setting up forms and table permissions to control user access

These steps are described in detail in the documentation:
👉 Manage SharePoint documents

The improvement is focused on how permissions are granted behind the scenes, not on introducing additional complexity for makers or admins.

We are looking forward to your feedback, which will help us continue to build on and improve the capabilities of this feature. We want to hear from you!

The post More Secure SharePoint Integration in Power Pages with Site‑Scoped Permissions appeared first on Microsoft Power Platform Blog.

Custom tools and rich UI for app-based conversations are now in Public Preview

Hemant Gaur — Wed, 22 Apr 2026 19:11:22 +0000

Earlier this month, we announced that Microsoft Power Apps applications can now be part of your Microsoft 365 Copilot conversations – letting users interact with their model-driven apps directly from Copilot. Today, we’re unlocking the next phase with custom tools and rich app-powered UI, giving customers the flexibility to build and shape experiences their own way.

These capabilities let you go beyond the built-in app tools for grids and forms that you can already enable with a few clicks for any model-driven app. Taking the next step in this journey, makers can now create tailored business actions, combined with immersive, interactive experiences, powered by Copilot and Microsoft Work IQ. Custom tools and rich UI components get added to the same app’s MCP server that also includes the built‑in app tools. With these new capabilities, Copilot experiences can feel less like requests and more like collaboration – visual, contextual, and action‑ready. Whether tracking case progress over time, spotting friction in a business process, or staying aligned on customer outcomes, insights can be presented in ways that naturally guide the next step.

Custom tools: Your app’s logic in Copilot

Your app’s MCP server already includes built-in app tools for querying, creating, viewing, and editing records in Microsoft Dataverse. Custom tools let you extend the app agent with your own MCP-powered actions, authored directly inside Power Apps using a prompt builder designer.

Each tool has a name, description, and instructions that tell the AI model what data to produce, and Copilot uses the tool metadata to decide when to invoke it.

Copilot can dynamically chain multiple tools together using the tool input parameters. For example, a “Sankey Chart Visualizer” tool can accept data which could be sourced from a natural language Dataverse query. The tool can then transform it into a weighted flow structure, and pass it to a widget for visualization – all triggered by a single natural-language prompt.

App-powered UI widgets

Widgets are self-contained, MCP-compliant HTML files built on Fluent UI that automatically adapt to light and dark Copilot themes. As part of this release, we are also introducing the generate-mcp-app-ui skill in Claude Code and GitHub Copilot CLI to help you quickly build widgets using natural language.

The skill produces a polished, theme-aware widget, ready to drop into your custom tool’s UX field.

How to get started

Step 1 – Enable your app’s MCP server – Open your model-driven app in Power Apps, select the App MCP icon in the left nav, and choose Set up MCP.

Step 2 – Add custom tools – In the Tools section of the App MCP tab, select Create custom tool. Give your tool a clear name and description (Copilot uses these to decide when to invoke it), write the Dataverse query instructions, or prompt using input parameter, and finally test the JSON output.

Step 3 – Attach a widget (optional) – Generate a widget for your tool using the /generate-mcp-app-ui skill and JSON tool output above. Test locally and then paste it into the tool’s UI field on step 2 of the tool editor.

Step 4 – Deploy – Download the updated app package and upload it to Microsoft Teams or publish it through the Microsoft 365 admin center for your organization.

Under the hood

This feature uses the Microsoft 365 Copilot extensibility platform and its MCP Apps capability. Power Apps generates an MCP server and a declarative agent from your model-driven app, and custom tools and widgets plug directly into that agent – no separate infrastructure required.

Documentation

Prerequisites: a model-driven app, a Microsoft 365 Copilot license, and permission to upload custom apps in Microsoft Teams. This is a preview feature – available for model-driven apps only at this time starting with early release stations.

We’d love to hear about what you build. Share your feedback and ideas through the Power Apps Community.

The post Custom tools and rich UI for app-based conversations are now in Public Preview appeared first on Microsoft Power Platform Blog.

Intelligent apps, human leadership, and the new shape of work

Tiffany Treacy — Mon, 20 Apr 2026 15:00:00 +0000

When people talk about AI at work, the conversation usually jumps straight to speed. Faster tasks. Faster decisions. Faster output.

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.

Build solutions with low-code tools from Microsoft Power Platform

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.

Drive innovation across your business with Microsoft Power Platform

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

Microsoft Power Platform Blog

What’s new in Power Platform: May 2026 feature update

Get started with the latest updates today!

Power Apps

Generally available: Power Fx user defined types (UDTs)

Agentic apps

Public preview: custom tools and rich UI for app-based conversations

AI powered development

Input support for generative pages

Migrate your InfoPath forms to Power Platform with coding agents

Building modern apps

Modern control updates for Button, Slider, Icon, and Dropdown with Icon now supporting OnSelect

Generally available: Grid container with drag-and-drop authoring and full undo/redo

Public preview: New Data Grid control – a Fluent UI based grid with search, sort, and multi-select for high-density data

Learning updates

Training paths and labs

Power Apps maker

Power Automate

Power Pages

Power Platform administration

Power Platform developer

Power Platform connectors

Power Fx: User Defined Types Generally Available

Records and Tables as parameters and return values

UDTs and JSON

IsType and AsType

RecordOf

Let’s go!

Power Apps MCP server introduces closed-loop learning for enterprise agents

How closed-loop learning works

Inside the research

The approach

The evaluation

The results

How Genetic-Pareto calibrated the agent

Closing the loop

What comes next

Agentic Administration: Dataverse Admin Skills now available in Public Preview

Dataverse Is Your Agent Data Platform: Here’s What’s New

Dataverse in Microsoft 365 Copilot

Business skills: teach agents how your organization works

Dataverse plugin: coding agents now speak Dataverse

Dataverse agentic evolution: from experimentation to execution

Introducing business skills: Teach agents how your organization works

Business skills: Process knowledge that agents can follow

Seeing it in action

Create, share, and govern — all from Power Apps

Who should use business skills?

Velrada enables consistent process execution for equipment inspections

Get started

From Ideas to Impact: How Frontier Firms scale agents with confidence

Start with workflows, not agents

Vision needs a roadmap

Adoption is a capability, not an event

Security and governance enable speed

Focus on value, then scale deliberately

Measure what actually matters

What separates leaders from the rest

More Secure SharePoint Integration in Power Pages with Site‑Scoped Permissions

Key improvements

No change to Admin experience or configuration flow

Custom tools and rich UI for app-based conversations are now in Public Preview

Custom tools: Your app’s logic in Copilot

App-powered UI widgets

How to get started

Under the hood

Documentation

Intelligent apps, human leadership, and the new shape of work

Intelligent apps change the role of the human

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

Automation works best when agents specialize

The advice I keep giving customers is straightforward: Start deliberately