Generative UI: Intelligent UI, OpenUI and Designers

For thirty years, software has worked the same way: designers create fixed screens, and people learn how to use them. In October 2026, two launches pushed hard on a different idea. On October 7, OpenAI brought Intelligent UI to ChatGPT, letting answers arrive as interactive interfaces instead of text. On October 15, the open-source project OpenUI reached version 1.0, offering a way for any AI agent to render interfaces from a team's own components.

This is generative UI: interfaces assembled by AI at the moment you need them. This article explains what that means, how these two approaches work, and what it changes for UI/UX designers.

In short: in generative UI, designers stop drawing every screen and start designing the components, rules and judgment the AI uses to build screens on the fly.

What generative UI actually is

In a traditional product, a designer decides in advance which screens exist and what goes on each one. In generative UI, the system decides at runtime. It looks at the request, the context and the data, then picks components and arranges them into an interface for that moment.

A simple way to picture it: ask an assistant to compare three laptops and, instead of three paragraphs, you get a side-by-side comparison with filters. Ask it to plan dinner and you get a recipe with a timeline and a guest-count slider that updates quantities.

The important detail is that good generative UI is not the model inventing pixels from nothing. Both approaches below work from a defined component library. The AI composes; the components and rules keep it grounded.

ChatGPT's Intelligent UI

On October 7, 2026, OpenAI released GPT-6 to ChatGPT users more broadly and introduced Intelligent UI. According to OpenAI, ChatGPT can now answer with graphics, tappable buttons, forms, charts and interactive experiences directly in the conversation.

How OpenAI describes it

The model chooses the format based on the question: side-by-side for comparisons, interactive diagrams for explanations, plain text when that's most useful.
OpenAI built a library of native, streamable components plus a compiler that processes the interface while the model generates it, so the UI appears progressively instead of after the whole answer is ready.
The library gives every response a familiar design foundation, while the model decides how the pieces fit together.
OpenAI trained the model to make design decisions about content, layout, visuals and interaction, and evaluated the interfaces it creates for clarity, usefulness and completeness.
You can also ask ChatGPT to build a small tool for the task at hand, such as a savings calculator or a bill splitter.

OpenAI is candid that there's "still work ahead to improve the model's design judgment". Its stated direction is bold: instead of people adapting to software, software adapts to people.

Availability. Intelligent UI started rolling out on October 7 to ChatGPT Plus, Pro, Business and Enterprise in the Chat tab, then to Free and Go from the next day. Enterprise availability depends on admin settings.

OpenUI 1.0: generative UI for any agent

ChatGPT's Intelligent UI lives inside ChatGPT. OpenUI, maintained by the company Thesys, aims to bring a similar pattern to any product with an AI agent. It's open source under the MIT license and reached 1.0 on October 15, 2026.

How it works, in plain terms

You define, or reuse, a component library: the cards, charts, forms and buttons your product allows.
OpenUI generates prompt instructions from that library.
The model answers in OpenUI Lang, a compact, streaming-first language designed for model-generated UI.
A renderer turns that output into real interface elements as it streams in.

Because the model can only use the components you register, the library acts as a guardrail. Version 1.0 adds custom actions, so buttons inside a generated interface can trigger your app's own code, and it works with different models, including open-weight ones.

According to the project, it has runtimes for React, Vue, Svelte and Angular, with extra ready-made components and chat interfaces for React. Thesys claims OpenUI Lang uses up to 67% fewer tokens than JSON, and a vendor benchmark reported in coverage of the launch compares it favorably with other generative-UI formats. Treat those numbers as the maker's claims, not independent results.

Two approaches, one shared idea

Intelligent UI is one vendor's experience inside one product. Designers can't change its components, but it shows millions of people what generative UI feels like.
OpenUI is infrastructure. Product teams bring their own design system and decide exactly what the AI is allowed to show.

Both rely on the same principle: a constrained component library plus model judgment. That principle is where designers come in.

What this means for designers

1. You design the system, not every screen. When interfaces are composed at runtime, the most valuable design artifact is the component library and the rules for combining it. Each component needs a clear purpose, states and boundaries.

2. Components need to be "AI-readable". A model picks components based on names, descriptions and examples. Vague names and undocumented variants lead to poor choices. Document when to use each component, when not to, and what data it expects.

3. Design for composition. A card may appear alone, in a grid, inside a chat bubble or next to a chart. Components must look right in combinations you never drew. Test them in unusual neighbors and widths.

4. Define when not to generate UI. OpenAI itself says sometimes plain text is best. Write rules for when interactivity helps, such as comparing, adjusting inputs or completing a task, and when it's noise.

5. Streaming changes layout. Interfaces that appear progressively need stable skeletons, sensible order and no jumpy reflows. Think about what shows first and what fills in later.

6. Trust and control matter more. When the AI builds a form or a button, users need to know what it will do. Clear labels, previews before actions and easy ways to undo or edit become essential.

7. Accessibility can't be an afterthought. Generated layouts still need focus order, labels, contrast and screen reader support. Bake these into components so every composition inherits them.

A practical starter checklist

Pick the 10 to 15 components that cover most of your product's answers: text block, card, list, comparison, chart, form, button group, map, timeline, empty state.
Write a one-line purpose and usage rules for each, plus correct and incorrect examples.
Define required and optional data for each component so the AI knows what to fill in.
Set composition rules: maximum nesting, how many primary actions per view, when to use a chart instead of a table.
Design loading and partial states for streaming.
Decide which actions need confirmation before they run.
Build accessibility into every component.
Review real generated outputs every week and turn repeated mistakes into new rules.

Limits and open questions

Design judgment is still developing. OpenAI says so directly, and generated layouts can still be cluttered or inconsistent.
Predictability versus flexibility. Fixed screens are easier to test and document. Generated ones vary, which makes QA and analytics harder.
Brand consistency depends on the library. A weak component system leads to weak generated interfaces.
Benchmarks are early. Performance claims for generative-UI formats mostly come from vendors.
Not everything should be generated. Core flows like checkout or settings often benefit from stable, familiar layouts.

How this connects to earlier trends

Generative UI isn't arriving alone. Figma's new Code Layers and Specs, design system guidelines for AI agents, and tools like Claude Design all point in the same direction: designers increasingly shape the systems, context and rules that AI uses, not only the final pixels. If you've already invested in a clean design system, you're in a strong position.

Conclusion

Generative UI moves the designer's work one level up. Instead of drawing every possible screen, you design the building blocks, the rules for combining them and the judgment about when an interface helps at all. ChatGPT's Intelligent UI shows the experience to a huge audience; OpenUI shows how product teams can build it with their own components. In both cases, the quality of the result depends on the quality of the system behind it, and that's design work.

Sources

Information checked on October 16, 2026.

Generative UI Is Here: ChatGPT Intelligent UI, OpenUI and What It Means for Designers