For most of software’s history, interfaces were finished before anyone used them. A designer decided what each screen would hold, an engineer built it, and every user got the same layout.
AI is loosening that. Ask a capable assistant to compare three mortgage offers, and it can hand back a sortable table or chart, assembled in the moment around what you asked. That’s generative UI — and it changes what designing a product actually means.
We’ve been designing digital products for 15+ years and have lived through a few interface shifts up close (Vine started as an in-house experiment at Big Human). Here’s how this one works, where conversational patterns help or get in the way, and what it asks of design teams. If you’re already planning an AI-native product, we’re happy to talk it through.
Generative UI is an interface an AI model assembles at runtime, in response to what a user asks.
Most implementations sit on a spectrum, from static (the agent picks predefined components) to declarative (it describes UI as data) to open-ended (it generates the interface itself).
Open protocols like AG-UI, A2UI, and MCP Apps now handle much of the plumbing, so the hard problems left are design problems.
Chat is one interface pattern among many, and the strongest AI products move people out of the text box once a structured view would serve them better.
Your design system becomes the vocabulary the model works with, so its components and rules matter more than ever.
Generative UI (sometimes shortened to GenUI) is an interface that an AI model creates or assembles at runtime, based on the user’s request and context. A large language model (LLM) decides what the person needs to see and returns it as UI components: a chart, a booking form, a comparison card.
Google put an early example in front of the public in November 2025, launching generative user interfaces in the Gemini app and Search’s AI Mode alongside Gemini 3. OpenAI followed in October 2026 with Intelligent UI, which lets GPT-6 answer in ChatGPT with charts, forms, and working mini-tools alongside text.
Dynamic and personalized interfaces have been around for years. What’s changed is who makes the call. A designer used to anticipate every state in advance. Now the model makes some of those decisions live, inside limits the product team sets. That move, from designing screens to designing the rules screens get made by, is the real story.
Not every generative interface gives the model the same freedom. Most frameworks describe a generative UI spectrum with three broad patterns, each trading control for flexibility.
Static generative UI. The frontend owns every pixel. The model makes a tool call that selects one of a set of predefined components (say, a flight card) and fills it with data. The AI agent never invents layout, so results stay consistent with your brand. (CopilotKit’s docs call this the “controlled” pattern.) The tradeoff is flexibility: if a component doesn’t exist yet, the agent can’t show it.
Declarative generative UI. The model describes the interface as structured data, often defined with JSON schema, and the app renders that description using its own components. Google’s A2UI spec works this way, and OpenUI takes a similar approach with its own compact language. Because the model only hands over data, the code that renders the interface is code your team wrote.
Open-ended generative UI. The model, or a connected tool, returns a full interface surface, usually HTML rendered inside sandboxed iframes. MCP Apps, the first official extension to the Model Context Protocol, follows this pattern, letting tools return dashboards, forms, and visualizations that live right inside a chat. It’s the most flexible option and the hardest to keep consistent.
We’ve explored that open-ended end ourselves. Through Big Human Labs, we built Literally Anything, an experimental tool that let people create an app, game, or widget in the browser just by typing a prompt. The creations that worked best came from prompts that spelled out the design, the data source, and what to show at each step. The takeaway for product teams: the more structure the product supplies, the less the user has to.
A set of open standards now handles much of the wiring: - AG-UI (the Agent-User Interaction Protocol) handles the live, two-way connection between an agent and an app, streaming events and state updates as they happen. It grew out of CopilotKit and sits underneath the other specs as a shared transport layer. - A2UI is Google’s declarative format for describing an interface as data that each client renders with its own components. - MCP Apps consolidates earlier work from MCP-UI and OpenAI’s Apps SDK into one shared standard, supported in clients like Claude, ChatGPT, and VS Code. - CopilotKit is an open-source framework for building agent experiences into React apps. It runs on AG-UI and supports all three patterns above. - The Vercel AI SDK lets developers map tool calls to React components, a common starting point for static generative UI. - OpenUI, from Thesys, pairs an open-source framework with OpenUI Lang, a compact language built for streaming interfaces from a model. Thesys also runs a managed API for teams that would rather not host it themselves. Coding agents like Claude Code are also making it cheaper to expand the set of components a model can draw on.
We don’t prescribe a specific stack. We work with you to understand your business needs and recommend an approach from there, and if you’re weighing options now, we’re glad to talk them through. The protocols will keep evolving, and the design decisions underneath them will matter through every version.
Chat became the default AI interface almost by accident. It was flexible, familiar, and fast to ship, and those qualities made it the easy default long before anyone asked whether it was the best fit.
Good conversational UI design starts by asking where language actually helps. Natural language is great for expressing user intent (“find a quiet hotel near the venue that fits our travel policy”). It’s weak at the steps that follow: comparing options, adjusting a filter, confirming a booking. That’s where a generated view earns its place. The conversation captures what someone wants, then hands them something structured to act on.
A few patterns we lean on in chatbot UX design:
Show the next move. Suggested prompts and quick-reply chips tell people what the system can do.
Make generated views editable. If the AI returns a table or a form, users should be able to adjust it directly, without having to re-prompt and hope.
Design the in-between states. Streaming text, partial results, and loading skeletons need intentional treatment. Google has said its implementation can sometimes take a minute or more to generate a full interface, and that wait has to feel productive.
Plan for recovery. When the model misreads a request, the fix should be one tap away.
Voice raises many of the same questions; our guide to voice user interface design covers that side.
Here’s the shift we think most teams underestimate. In a generative product, the design system also becomes the vocabulary the model speaks, alongside its usual role as a reference for your designers and engineers.
An LLM can only compose with the pieces you give it, and only uses them well if it understands them. Beyond polished React components, each piece in your library needs a clear purpose, documented properties, and rules for when to use it, written so a model can read them. Teams increasingly encode that in JSON schema definitions and system instructions that ship alongside the components.
This is also where your brand survives. When an AI agent assembles a screen on the fly, no designer is reviewing every frame, so consistency has to come from constraints. Tight tokens, a deliberate set of widgets, and well-defined UI components keep a generated screen feeling like your product. (It’s the same lesson as answer engine optimization: AI systems do better with content that’s clearly structured and described.)
Systems work has long been part of our UI/UX design practice. The difference now is a second audience: the model working alongside your team.
A few scenarios we see, and where they tend to land:
A regulated fintech or healthcare product, where every screen carries compliance weight, usually points to the static pattern.
A data-heavy B2B tool where people explore and compare often fits a declarative approach, so layouts adapt to the question while still looking like your product.
A platform that plugs in third-party tools may justify open-ended surfaces through MCP Apps, with sandboxing.
An early product still testing whether users want an AI layer at all may not need any of this yet. A well-designed conventional interface with one smart feature can teach you more, faster.
Generated interfaces add real complexity to testing, QA, and design governance. Our goal is to help a team pick the simplest approach that serves real users. When you’re ready to try an idea, rapid prototyping and usability testing will tell you quickly whether it’s actually helping.
Generative UI moves interface design work upstream, into the components, constraints, and conversational patterns that decide what a model can build and how the product behaves when it gets something wrong. Teams that treat it as a design problem are the ones best positioned to build AI products people trust.
At Big Human, our strategists, designers, and engineers work together on AI app development, from the first prototype through launch. For the product strategy side, start with our guide to how to build an AI app. And if you’re weighing where generative UI fits in your product, let’s talk about what you’re building.