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 the 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 summer, 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 these support for agent UIs finally land in mainstream Microsoft tools. Shared state unlocks some really transformative user experiences, such as these ones:
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âve to wait a bit longer.
But inside Microsoft, these kind 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 AI orchestration layers that serves 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 six 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 for using a CLI. See for example this demo of Copilot Studio agents built with Claude Code and agent skills.
I, for one, didnât see this 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.
Recetly, 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 (see above): 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 doing it also. 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 invoked 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.