Beyond Components: Designing Generative UI for MCP Apps — Ruben Casas, Postman

Okay. Hello everybody. So, I know I am the person standing between you and your lunch, but this is going to be a very interesting talk that combines the previous two talks into the future, and that's what I want to talk about today.

So, back in November 2022, what we used to do was we used to go to ChatGPT and ask ChatGPT to create a component, and we would just copy, paste. You had to ask, "Reply in code blocks," then, you know, again, fix it, repeat.

And this is what I call the poor man's bite coding. And we have come a long way. It kind of worked. It was very exciting. You could get models to actually build some UI for you. And surely that was not going to write better code than me,right?

And then things improved very, very rapidly. Very, very fast. What happened last year, and if you are aware of what happened in the last months of 2025, was this acceleration, an incredible inflection point where things changed. And it will go down in the history books as "things changed very fast all at once."

And this is in part because of the release of two very important models, which were 5.2 ChatGPT, sorry, it was, yeah, GPT-5.2 and Opus 4.5. And they were not just very good at most of the tasks, long-horizon tasks.

They were also very good at high-fidelity UI generation. And they were producing very good working UI, sometimes thoughtful, sometimes really, really good, and also very fast. Now, I experienced this when I tried one of these models, tried to rewrite my blog.

I know people have used this in more creative ways, but I just tried, you know, as a single prompt, "Rewrite my blog." And then it did this, which I didn't ask for. It created a nice search box with a blur animation, with accessibility out of the box.

And then that's when I realized that in the space of three years, from when ChatGPT was released to today, we went from, eh, you know, a few lines of code. It's great. It can it runs, oh, it now can write better frontend code than me.

And you know what? I don't mind. No ego. It's just reality. So here's a question. If these models are so good at writing UI code, why are we still stuck in this mainly-all paradigm of mostly static UI? And where is that JavaScript moment that we've been talking about earlier?

Where are my floating UI windows that appear and disappear? And why are we not there yet? So my name is Ruben Casas. I am a staff engineer at Postman. And I've been looking at UI and generative UI for the past year, and I've been working with MCP apps as well.

And today I want to show you what we're doing today and where we're going in the future. So the news are we have a new computer. And as Andrew Carpathy put it, "Interacting with this new computer is like talking to the terminal."

You have direct access to this operating system. And the GUI has not been invented yet. It's like we are in the '70s, where everything was just text. And we have a superintelligence, but we don't have a mature interface language.

And today we are still trying to figure out what is this new interface for this computer. And people ask, "Is it chat?" So I'll show you what we're doing today. And actually, this was a very recent tweet last week where people were complaining that most SaaS companies have been adding chat to their home pages, and everybody's just putting chat everywhere.

And that's fine. I don't have a problem with chat. It's not the final UI. It's okay for now. But the question is, if it's not chat, then what is the interface for this computer? On the other hand, as we have seen with MCP apps, there is another thought, which is we will have one app or a super app to rule them all.

And this is where MCP apps comes in, where instead of putting all of these chat windows into your home pages and into every single app that you use, we will have a super app like ChatGPT or Claude or Gemini, where you will be interfacing with most of the UI and the websites that we have today.

And this is good. This is the way we're using MCP apps today to render third-party UI inside one agent environment. Now, these two options both could be valid, and I believe these are part of the evolution towards finding out what is that new interface for that computer.

And to be honest, I don't know which one is going to be the final one. Consumers will tell us. But one thing is, these are two different questions. The question is, where does the UI run? So in this case, is it third-party UI, a super app, or in this case, chat everywhere?

But most interesting is, what is the model generating? And this is what I want to talk about today in terms of how are we generating this UI. And you have seen this. We have mostly static, declarative, and generative UI.

And I'm going to describe briefly this one. So we have, to start with, the static components way of rendering UI, which is what most agents do today. The agent is just an orchestrator. The agent makes a tool call via MCP apps, so the direct agent tool call.

Then we will have some parameters and data passed to predefined static components that have been created by developers. And this is very similar to what we have been doing for the past 20 years with UI. And then the client renders a component.

And if you see here, it's very similar to just getting a server to send some data, and then the UI will be rendered by the client. But in this case, the agent will be generating that data and the props to do this.

And some examples that we have today are the AG UI protocol. They have an SDK where you can register a client tool that maps to a React component. The tool call will receive some props. Those props will be mapped to a static component that then will be rendered to the user.

Another example is Goose. Goose is an MCP client where you can try most of the MCP features. And Goose has this really interesting feature called Goose auto visualizer, where you can just pass any type of data to Goose, and Goose will try to match that data, organize it, and then pass it to a set of predefined components that the Goose team have created.

In this case, we have a few interesting components that you can use to visualize your data. So that's the static way. That's the most common way of generating UI today. But I have seen an evolution recently, what we call now declarative UI.

And declarative UI takes it to the next level. So we will still have some predefined static components that developers build, and it contains your design system and all of these components that you have. But instead of the agent just passing the props and the data, the agent uses a descriptor that could be either JSON or YAML, or I've seen Python as well with FastMCP2, and they have a descriptor in Python that maps to these predefined static components.

And then you have this translation rendering engine that takes those descriptors and converts them into the final UI. How is this different? Well, in this case, it is more dynamic. There are still static components, but it's more personalized.

And if you look at this and you think that this might look familiar as well, it's because it is not new. Netflix has been doing this for a long time, since the personalization and server-driven UI era, where when you go to the Netflix homepage, you will get a UI that is completely personalized to you.

But that's still mapped to the Netflix components and UI elements. Another very good tool that I have seen recently is JSON Render. JSON Render has been built by Vercel. And it is a way to map your components using JSON and also YAML.

They released the YAML support recently. And create all of these very dynamic, very good UI interactions that you can use today. But now JSON Render still, they say, is constrained to your static components. And yes, there's still static components.

The LLM is not generating those components. The LLM is generating the JSON. However, I think at this point in time, declarative generative UI is probably the perfect balance today in terms of flexibility and consistency, because you still want your design system, you still want to have predictability of what the UI is going to be generated, also faster, and also potentially cheaper at this point, so you don't create and use a lot of tokens to create the UI.

But as I mentioned at the beginning, why are we still stuck here? And what's the next level? I think the next level would be generative components. And generative components

goes into the premise I put at the beginning, where the models are good at writing frontend code. They are good at writing React. They are good at creating JavaScript, CSS. And the question is, why we don't let them just write that on demand at runtime?

What could possibly go wrong with that,right? This model of generating the UI uses the agent capabilities. And in this case, you can also use a tool call. But instead of calling this layout rendering engine, you can call the same model with reverse sampling, or you can call another model that will generate the HTML, CSS, JavaScript on demand, and then it will be passed to the client.

I did this experiment. I work at Postman on this experiment where I created this weather agent that goes to the API, the weather API. It creates a joke. It creates the HTML, CSS, JavaScript, all in one tool call.

And you get presented with this random, but very imaginative UI where everything is created by the agent. There is no component. There is no translation. So there is, of course, a problem with this approach. And the problem with this approach is, if we don't trust third-party code, well, we should not trust code that is being generated by LLMs and then just presented to the user.

Generative UI, and this level of generative UI, needs a distribution model. And this distribution model requires a boundary, requires containment, and requires a sandbox, which is what we were talking about earlier. This is where I think MCP apps matter a lot, because MCP apps are the best delivery mechanism for generative UI.

We have the features provided by MCP, including authentication and tool calling and message passing between the UI and the agent. It's sandboxed by default with that double iframe. It's the default for third-party UI delivery today. That's become the standard.

And one interesting thing is, it's not just for third-party UI. It can also be used for first-party UI. And this is why I think what Anthropic is doing with the visualizer feature is very interesting, strategically speaking, because they could have just created their own rendering and architecture mechanism for delivering this interaction in Claude.

But they decided to go with MCP apps, because MCP apps provide most of those features that I mentioned earlier out of the box. So if Anthropic decided to use MCP apps for their first-party UI, you can ask yourselves, why cannot we do the same?

It is a very, very strong protocol. And especially when the UI is being generated on the fly by the agents, by the coding models, then it's the best mechanism for delivery. Now, today is probably not the final form.

And people keep saying, is chat the final form? Is MCP apps the final form? We're still trying to figure this out. And the obvious future is probably too obvious. And we said about, where is my Jarvis? Where is my floating windows?

And if you think about it, that's the obvious thing that people would think, how it would look like if we were generating or creating a new user interaction. But what I think is, we don't have enough imagination yet.

And this analogy I heard recently is very interesting. When radio came out in the '30s,

the first sorry, the TV came out. The first TV shows were radio shows with cameras, because they could not imagine what you could do with this new technology. So this new technology that we have today is very similar when television came out.

And we are still in the radio era, where we don't know all the amazing things that we will do in the future with this new media, with this new power that we have with the new computer. And we can see that we cannot even imagine what it's going to look like.

Of course, this is speculative, but what do I think is actually going to happen is, we are going to be moving beyond components and more towards a collaboration, true human-agent collaboration. If you haven't heard about the Skeletro MCP app, definitely check it out, because the Skeletro MCP app is not just for output and visualization of diagrams.

The Skeletro MCP app does something very interesting, which it creates a shared artifact. It creates a canvas where a human and an agent can collaborate together into a shared space, where you can go back and forth with the agent and ask, change this.

But you can also click around, modify the UI the way that you are used to. And that becomes the new way of interacting, the new way of experiencing the agent powers. And at the moment, again, we are very constrained to our imagination.

And I believe these agents are very, very powerful to just use them as an orchestrator and a delivery mechanism to show me some visualizations. So I believe beyond components, it will be the future of generative UI will be more a collaborative experience, where, yes, we will have some generative UI, but that UI is going to be super personalized, and it's going to be collaborative.

So we are still early. We don't have the answer. People say, you know, what is the future of the user interaction, the user interfaces? We don't know yet. But we can shape that future and create this new computer.

And that's me. Thank you so much for listening to this. You can find me and ask any questions. Thank you.