The advent of Model Context Protocol (MCP) APIs hints at a coming era of agent-driven architecture. In this architecture, the chat interface becomes the front end and creates UI controls on the fly. Welcome to “generative UI.”

The new portlet

Once upon a time, the portal concept promised to give every user a personalized view. Finally, the promise of a web where the user was also the controller could be realized. That didn’t quite work out the way we thought. But today, generative UI proposes to take UI personalization to a whole new level, by marrying bespoke, as-needed UI components with agentic MCP APIs.

The old way involved writing back ends that provide APIs to do things and writing user interfaces that allow humans to easily take action on those APIs. The new idea is that we’ll provide MCP definitions that allow agents to take actions on the back end, while the front end becomes a set of definitions (like Zod schemas) that expose these capabilities.

One of the greatest things about having observed the industry over a long stretch of time is a healthy skepticism. You’ve seen so many things arise and promise the moon. Sometimes they crash and burn.  Sometimes they become important. If they are useful, they are absorbed into the developer’s toolkit.

This skepticism isn’t even a conscious thing anymore; it’s an instinctual reaction. When someone tells me that AI is going to produce user interfaces on the fly as needed, I immediately begin raising objections. Like performance and accuracy. 

Then again, the overall impact of AI on development has been significant, so let’s take a closer look.

Hands-on with generative UI

I’m thinking about generative UI as a kind of evolution of the managed agentic environment (like Firebase Studio). With an agentic IDE, you can rapidly prototype UIs by typing in a description of what you want. GenUI is a logical next bridge, where the user prompts the hosted chatbot (like ChatGPT) to produce UI components that the user can interact with on the fly.

In a sense, if an AI tool, even something like Gemini or ChatGPT with Code Live Preview active, becomes powerful enough, it will push the person using it to wear the user hat, rather than the developer hat. We’ll probably see that occur gradually, where we eventually spend more time designing rather than coding, diving into developer mode only when things break or become more ambitious.

To get hands-on with this idea, we can look at Vercel’s GenUI demo (or the Datastax mirror), which implements the streamUI function:

The streamUI function allows you to stream React Server Components along with your language model generations to integrate dynamic user interfaces into your application. Learn more about the streamUI hook from Vercel AI SDK.

Vercel’s GenUI demo will give you a taste of what is meant by on-the-fly UI components streamed alongside chat interaction:

Foundry

This is just a demo and it does the job of getting across the idea. It also exhibits plenty of typical AI foolishness and limitations. For instance, when I ask to buy “some Solana” in a stock buying chat it replies “Invalid amount.” So then I ask to buy “10 Solana” and it gives me a simple control with a Purchase button. 

Of course, this is all for play, and there is no plumbing backing up that purchase. Creating that plumbing would be non-trivial (wiring up a wallet or bank account and all the attendant auth work). 

But my purpose is not really to fault-find the demo. Some of the issues can be cleaned up with concerted developer work. Others are down to current limitations of large language models. By that I mean, there is a strange collision between the initial feeling of vast potential you get when using an AI or agentic tool and the hangover period of frustration that follows, when you suddenly find yourself with a mountain of AI-initiated “work” that will require hours of human concentration to master and wrangle.

It’s like you had a bit too much coffee and the caffeine wore off. Now you’ve got to roll up your sleeves and wrestle all of the big ideas into functioning software.

Vercel’s is not the only generative UI demo we can look at. Here’s another from Thesys:

Foundry

Microsoft’s AG-UI offers similar capabilities.

Is generative UI a good idea?

But let’s imagine that the genUI APIs and LLMs progress beyond their current state, and developers aren’t left with the heavy lifting. The main question is: Is a generative UI something we as human beings would ever actually want to use?

To be fair, the Vercel genUI is an API that is for use in other apps. That is to say, it allows you to stream UI components into the flow of AI responses. So maybe integrating on-demand React components via the streamUI API could really be just the thing in the right setting of another, well-considered UI. 

It seems like a good UI with good UX is still the lion’s share of what people will use. I mean, I might sometimes want to ask my AI to find good deals on a flight to Kathmandu and then have it pop up an interface for buying the ticket, but usually I will just go to Expedia or whatever. 

Even if you could perfectly express intention as a UI, when you finally do get a perfectly useful UI, you probably won’t want to continue to modify it in deep ways. You will want to save it and reuse it.

Typing out intention in English (or Hindi or German) is great for certain things, especially researching, brainstorming, and working through ideas, but the visual UI has huge advantages of its own. After all, that’s why Windows supplanted DOS for many uses.

But I hasten to add I’m not dismissing the idea out of hand. Perhaps some hybrid of designed UI along with chatbot prompt that can modify it on the go is in the cards.

An essential insight here is that if the web becomes a cloud of agentic endpoints, a realm of MCP (or similar) capabilities that give action to AI, then it will be a kind of marketplace of possible actions we can take using a neutral language interface. And the on-demand, bespoke UI component will become an almost inevitable element of that landscape.

Instead of a vast collection of documents and data, the web would be a collection of actions that could be taken based on intention and meaning. 

Of course, the semantic web was supposed to make a web of meaning, but with AI a semantic web could be more practical. GenUI would be a new kind of way to provide tool definitions for engaging with that web.

Context architects

There is something here, but I don’t see genUI replacing UX and UI engineers anytime soon. Augmenting them, perhaps. Providing them with a new tool, maybe.

Similar to vibe coding, the idea that we’ll spend our time “architecting a context” using AI, rather than building interfaces, likely contains some of the character of the coming world of front-end development, but not the whole story.

The work of a UI developer in this model would consist of providing interface definitions that mediate between the chatbot and MCP servers. These definitions might look something like the snippet below.  Vercel’s API uses Zod. This is just a pseudo-example:

// This Zod schema acts as the "Interior Interface" for the AI Agent
const cryptoPurchaseTool = {
  description: 'Show this UI ONLY when the user explicitly asks to buy',
  parameters: z.object({
    coin: z.enum(['SOL', 'BTC', 'ETH']),
    amount: z.number().min(0.1).describe('Amount to buy'),
  }),
  generate: async ({ coin, amount }) => {
    // The AI plays within this sandbox
    return 
  }
}

In a sense, this schema becomes the “interior UI” available to the AI, and the AI itself becomes a kind of universal human-machine intermediary. Is this really where we’re going? Only time will tell.