The death of BizApps and the rise of the agentic Power Platform

Sometime last summer, it started to dawn on me that business applications as we know them might soon be a thing of the past.

I had been experimenting with the Model Context Protocol for a while, building custom agents that read and wrote to Dataverse directly - no UI in between. Talking to my business application in natural language, with MCP doing the plumbing, was unexpectedly delightful - and surprisingly productive. If you are interested, you can find some of my early experiments with Dataverse and MCP here and here.

It was early days, before the release of the official Dataverse MCP Server - so I had to roll my own - which turned out to be surprisingly easy, especially given the fact that LLMs are really good at FetchXML 😊.

Accessing Dataverse from an agent in this way was fun and all, but it became pretty clear that text might not be the optimal modality for using business applications, mainly because it is painfully slow (local speech-to-text helps somewhat, see this demo). This got me thinking - what if the agent could surface user interfaces when the user needs them - in addition to text?

Once again, it was early days and there wasn’t much available in terms of standards or specifications for agentic user interfaces. AG-UI, OpenAI Apps SDK and MCP Apps, all of which I’d later spend a lot of time exploring, hadn’t been announced yet. So, lacking official specs and tooling, I started rolling my own agent UIs.

Nowhere near enterprise-ready, but during this time I built a few demos that explored these ideas. One of them showed a bespoke agent UI that pulled in Power Apps screens when needed, and rendered reports dynamically from natural language:

We started showing this to customers, and the response was simply overwhelming. “We want this!” they said after nearly every demo - the idea that you could just ask for what you needed and have the right UI appear, instead of clicking through menus and tabs, clearly struck a chord.

But there was a problem: the technology simply wasn’t there. These were just demos, and even though the benefits of agent UIs were clear, shipping this to customers felt a long way off.

Some specs, finally

But then last autumn, things started happening. First, quietly on the open-source side, MCP-UI showed up - an early attempt at formalizing how agent UIs could be served over MCP (here’s my demo from August). Then the frontier labs followed:

• OpenAI Apps SDK - announced in October.
• MCP Apps - announced in November, as an extension to the MCP protocol from Anthropic.

MCP Apps was directly inspired by MCP-UI, so credit to the MCP-UI team for paving the way.

Going back a bit further - last spring, a small, then-unknown company called CopilotKit released AG-UI, the spec that, more than any other, piqued my interest in agent UIs. I’ve since explored it in depth, including a session at AgentCon (video summary) and in a conversation with Rasmus Wulff Jensen. For deeper dives, see my LinkedIn writeups here and here.

One specific concept in AG-UI - Shared state between the UI and the agent orchestrator, and a core part of the AG-UI spec - is, in my view, the single biggest unlock for agent UIs, and one piece that is still missing as support for agent UIs finally lands in mainstream Microsoft tools. Shared state unlocks some really transformative user experiences, such as these:

Suddenly, the demos from a year earlier didn’t look quite so far-fetched - the pieces in the agentic UI puzzle were starting to come together.

The death of BizApps

So while agent UI standards started emerging at the end of last year, support for them was still lacking in the Microsoft ecosystem. Our customers were eager to start trying these experiences in Microsoft Teams and M365 Copilot, but as it turned out - they would have to wait a bit longer.

But inside Microsoft, these kinds of ideas had apparently been brewing for quite some time. Already back in December 2024, on the BG2 podcast Satya Nadella famously predicted the eventual death of SaaS applications as we know them, in favor of AI orchestration layers that serve agents directly.

Charles Lamanna was even blunter. In a May 2025 conversation with Madrona he said:

“As the guy at Microsoft who works on business applications, sometimes the truth hurts, but business apps as we know it are indeed dead … Instead, what will probably happen is you’ll see this ossification of these classic biz apps, the emergence of this new AI layer, which is very focused around automation and completing tasks in a way that extends the team of humans and people with these AI agents that go and do work .. You’re going to have a generative UI, which AI dynamically authors and renders on the fly to exactly match what the person’s trying to do .. The gist of it is yes, indeed, biz apps, the age of biz apps is over.”

The coming war of the AI Capabilities Layer

And it’s not just the apps. At the Power Platform Community Conference 2025 in Las Vegas, Lamanna delivered the line that lit up the low-code community: “Low code is dead, as we know it.” That caused quite a stir - but seven months on, it looks less like the low-code frameworks themselves are dying, and more like the way we use them is changing. Instead of clicking around a designer to build a low-code app, we’re letting our agents build them using a CLI. See for example this demo of Copilot Studio agents built with Claude Code and agent skills. Honestly, I didn’t see that one coming.

Another harbinger of things to come - and one I have quoted repeatedly - is Lane Swenka’s blog post from last summer, laying out a new direction for Power Platform admin tools: a transition from UX-first to API-first. The scope was seemingly limited to admin tooling, but in hindsight it was pretty clear that it pointed to something bigger - an API-first shift across the whole Power Platform, to cater for the needs of AI agents.

Recently, this article by Todd Trotter about the Capabilities Layer - the architecture and plumbing needed to serve AI agents - is one of the best summaries I’ve read of where all this is heading, and what it means for the Power Platform.

“AI needs applications to describe what they can do, what their constraints are, and what state they are operating against. They need a surface that is designed to be composed … That surface is the Capabilities Layer. It sits between your application services and any consumer - human, agent, or orchestrator - and it exposes typed tools, structured data resources, and interactive UX components through MCP.”

One concept in particular stands out - the idea of “micro-frontends”:

“Micro-frontends apply service-style decomposition to the user interface by splitting the frontend into independently developed and deployed features or components that are composed into a larger experience.”

Some corporate-speak, sure - but he’s basically saying the same thing as Charles Lamanna was saying: the user experiences of the future will surface when they’re needed, with just the UI elements the user needs, no more, no less. We’re heading toward a world where dynamically surfaced, agent-centric “micro experiences” are the norm.

So the vision from Microsoft is pretty clear: agentic user experiences FTW, and the infrastructure, APIs and MCPs to support them. And they’re not the only ones reaching this conclusion - Salesforce’s recent Headless 360 announcement is the same play, and SAP, ServiceNow and the rest are also doing it. The platforms are being (re)built to be consumed by an army of autonomous agents, and the human-facing UIs - when they’re needed - will be dynamic and served by the agents.

The writing is on the wall; this is the war that’s coming. And when the dust settles, the winner will be the provider with the best Capabilities Layer for agents - and the best support for agent UIs.

But vision is one thing; execution is another. With the coming clash of the titans to build the best capabilities layer as backdrop, let’s look at what Microsoft has actually shipped lately in this space.

The rise of the agentic Power Platform

In all honesty, being passionate about agent user experiences and at the same time being a consultant in the Microsoft space last year wasn’t all that great. With the explosion of specifications in the agent UI space we saw late last year, I had high hopes that these capabilities would be promptly made available in the Microsoft tech stacks. Perhaps support for MCP Apps for Copilot Studio agents? Or why not an iteration on the Adaptive Card spec to support dynamic user interfaces? Or maybe AG-UI support in M365 Copilot? One could only dream…

But Ignite 2025 came and went without any real announcements in this space, so I kept waiting and hoping, hoping and waiting. And good things come to those who wait, because on the 9th of March 2026, somewhat hidden in the Microsoft 365 Copilot Blog was this little nugget:

Support for OpenAI Apps SDK was already available, with MCP Apps coming soon. I found some really cool samples which I used to create my own demo:

This feature was part of a capability exclusive to Microsoft 365 Copilot declarative agents, marketed as “interactive UI widgets”, part of “MCP plugin actions” (more info here).

For some reason, all these new fancy capabilities related to support for agentic UI protocols were implemented for declarative agents, a technology I hadn’t tried before - I had mostly dabbled with Copilot Studio agents and agents built with custom code (referred to as custom engine agents in the M365 Copilot nomenclature). So this gave me the chance to explore declarative agents, which was pretty interesting.

Then, it was announced that it was possible to use M365 Copilot agents in a Power App. At first glance, the benefit of this is to run the main M365 Copilot agent from a Power App - which is already grounded in your organization’s data, but which now also indexes the data in your Power App environment. It’s not the first time we have seen Copilots in Dynamics/Power Apps, but this time it seems to actually work pretty great:

A limitation of this “standard” M365 Copilot agent is that it can’t really “do” anything in Dataverse - it can read data just fine, but it can’t modify anything.

To remedy this, you can also access your custom agents (declarative, Copilot Studio or custom engine agent) from M365 Copilot in your Power App, and this is where it starts to become really cool! I created a demo of this, once again using the Microsoft samples. This means that if your custom agent is equipped with e.g. the Dataverse MCP Server, it can update data in Dataverse. One big limitation currently is that the custom agent has no context - it doesn’t know which Power App/form/view/record it is using:

I hope that this will change soon - context-awareness for custom agents is such an unlock that it should have been implemented yesterday…

Next was the announcement that your Power App could expose its own MCP Server, which came with a set of custom MCP Apps UI tools. You could then download it as a declarative Copilot agent package, which you could deploy to your tenant. I created a demo of this as well:

Then came the announcement that custom tools could be added to your Power Apps, which became part of the MCP plugin actions when you exported the Power App as a declarative agent. Demo here.

And then on April 7 came the big one - support for MCP Apps in declarative Copilot agents! Since I had already created an MCP Server with some cool-looking MCP Apps UI components, I simply added them to a declarative agent which resulted in my most successful LinkedIn post to date:

And there is more - for example, the agent feed capability in Power Apps (demo here) and the ability to use your own custom agents in Microsoft 365 productivity apps, such as Excel and Word (demo here).

So, it feels like Microsoft is firing on all cylinders when it comes to agentic UIs, at least when it comes to declarative Copilot agents. The state of things has improved enormously since last year. So, kudos to everyone at Microsoft, and while we’re at it - here is my wishlist:

• Pretty please with sugar on top - make it possible for custom agents to be aware of their Power Apps context. Please?

• Let’s make it possible for all Copilot agents to use MCP Apps, not just declarative agents. Here’s an idea - make MCP Apps support a general functionality in M365 Copilot, that works for all agent types - declarative, Copilot Studio and custom engine agents. And perhaps in Teams too?

• Add a way to limit the number of user approvals needed when using MCP action plugins in declarative Copilot agents. There is so much clicking. 😉

• Implement some smart way of providing context to an agent UI that is synchronized with the agent backend. Similar to the context management feature in AG-UI. As stated above, this is the one thing that more than anything else unlocks the possibility to build real agentic applications.

What’s next?

So, we have talked about the agentic UI layer. But what about the AI Capabilities Layer that will power the rise of the autonomous agentic workforce? It seems to me that Microsoft is currently consolidating this capabilities layer under the Work IQ umbrella, at least when it comes to Microsoft 365 and Dataverse. A set of MCP Servers is available that could allow agents to interact with Microsoft services on behalf of the user, and eventually also autonomously - under their own agentic identity. I have played around with the Work IQ MCP Servers, and they are pretty neat.

But who is winning? On agent UIs, Microsoft has caught up impressively fast in just a few months. On the Capabilities Layer it might be a different game - one where the other big firms are moving in parallel and fast. One can only assume that massive efforts are underway internally at Microsoft to build out this Capabilities Layer and respond in force to Salesforce Headless 360, and the others. All the major players have reached the same conclusion - that the race for the AI capability stack is the race for the next era of enterprise software, and there are no prizes for second place. Game on!

So, are BizApps dead? Yes, it seems so. A year has passed, and I’d say it’s even clearer than it seemed back then. It’s still early days, but in a matter of months we could have dynamically generated agentic user interfaces and a mature capabilities layer that can power our agents, and honestly - who needs a business application then?

As always, thanks for reading and until next time - happy hacking!