# GPT-6 just made Generative UI mainstream. We think the next missing layer is Generative Workflow. — retained record

> Retained reddit record from reddit:AI_Agents.

Canonical: https://highsignal.app/data/records/b03944c0a858ba85

[← sources](https://highsignal.app/data)


source: [reddit](https://highsignal.app/data/reddit) (reddit:AI_Agents)  published 2026-10-09 01:58 ingested 2026-10-10 02:34

[original source ↗](https://www.reddit.com/r/AI_Agents/comments/1x195d8/gpt6_just_made_generative_ui_mainstream_we_think/)

## retained text



```
GPT-6's new Intelligent UI feels like an important shift in how we interact with software.

For a long time, AI mostly generated text, code, or answers.

Now we're moving toward AI generating the **interface for the task itself**: charts, forms, buttons, interactive components, and temporary tools assembled dynamically around what the user is trying to accomplish.

But this raises an interesting question:

**What happens behind the UI?**

Generating an interface is relatively easy to describe. Generating the system that actually *does the work* is a different problem.

Suppose I ask an agent:

>"Analyze this company's financial data, identify unusual changes, compare them with the previous quarter, and produce a management summary."

A Generative UI could present the result as charts, tables, controls, and interactive explanations.

But underneath, the system still needs to:

1. retrieve the right data
2. transform and validate it
3. run several analysis steps
4. maintain state between those steps
5. call external tools or APIs
6. produce intermediate results
7. let the user modify a specific step
8. execute the modified workflow again

That starts to look much more like a **workflow compiler/runtime** than a traditional UI system.

And I think this may become an important distinction in the next generation of agents:

**Generative UI = how the user interacts with the generated application**

**Generative Workflow = how the generated application actually performs the task**

The interesting part is that these two layers could eventually be generated together.

Instead of:

>prompt → answer

we may get:

>intent → UI + workflow → execution → feedback → workflow update → better execution

That also changes how we think about "agent skills."

A skill doesn't necessarily have to remain a static prompt or instruction set.

It could become a **living executable workflow** that can be inspected, modified, replayed, and evolved based on user feedback.

We've been experimenting with this idea in an open-source project called **FlowX**.

The current focus is turning natural-language requirements into executable workflows and allowing individual workflow nodes to be updated and rerun through conversation.

We're particularly interested in the larger question rather than just the implementation:

**If Generative UI is the new interface layer for AI software, what should the execution layer look like?**

Is "Generative Workflow" the right abstraction?

Or do you think agent systems will eventually converge on something else?

GitHub: AIpRoBuilder->FlowX
```



document fetched 2026-10-10 00:19 · canonical https://reddit.com/r/AI_Agents/comments/1x195d8/gpt6_just_made_generative_ui_mainstream_we_think
