After GPT-6 Ships Intelligent UI, Why Is the Interface Still JSON? From the ChatGPT Component Library to structuredContent

As of 8 October 2026: the Chat tab started rolling GPT-6 Sol with Intelligent UI to paid plans on 7 October; Free and Go get GPT-6 Luna from today. The component library is compiled inside the product. The tool result you hand the model is still structuredContent JSON.

Intelligent UI changes how ChatGPT draws an answer. The tool result you hand the model is still a JSON document. On 7 October 2026 OpenAI started rolling GPT-6 with Intelligent UI out in the Chat tab. Plus, Pro, Business, and Enterprise are powered by GPT-6 Sol from that day. Free and Go move to GPT-6 Luna starting 8 October. Both are tuned for everyday conversation. Enterprise visibility depends on the workspace admin. The models behind Work and Codex do not change in this release.

The mechanism in the post is short: a library of native, streamable components, plus a compiler that builds the interface as the model generates it. A reply can include graphics, tappable buttons, forms, charts, or a small tool made for the moment. A simple question can still come back as text. The model can also start answering while it is still thinking. Those sentences describe presentation inside Chat. They do not add a field named intelligent_ui to the API.

This piece is written for 8 October 2026, from the announcement, the developer note, and the model pages that were current that day, plus the MCP Apps docs. We already cover what Structured Output is, the Agents API and JSON Schema, and what MCP is. Here the only question is which JSON layer is still yours after the interface changes.

What shipped in Chat on 7 October

The post brings GPT-6 to more than 1.2 billion people who use ChatGPT each week, and adds Intelligent UI to Chat: text, visuals, and interactive blocks composed for the question. A comparison can sit side by side. An explanation can be a diagram you tap. A task can be a savings calculator, a bill splitter, or a small game in the thread. A simple question can still be plain text.

Two internal figures are not your benchmark. GPT-6 Extra High starts answering in about the same time as GPT-5.6 Medium, with a better overall score than GPT-5.6 Extra High. On questions that need web search, GPT-6 Instant starts answering 44% sooner on average than GPT-5.6 Instant. Safety training builds on advances already made for Astra. The detail lives in the GPT-6 system card, not here.

LayerChat tabYour API / MCP
Paid plansGPT-6 Sol from 7 OctoberA new model string does not mint this UI
Free / GoGPT-6 Luna from 8 OctoberSame boundary, and the rollout is staggered
Work / CodexModels stay putThis post is not a migration order
PresentationComponent library plus compiler, drawn as tokens arriveNo public Intelligent UI JSON dialect

Enterprise has an extra switch. If the workspace admin leaves it off, seats do not see it. The rollout is not one minute worldwide.

This is not a new API schema

The model-page IDs are gpt-6-sol and gpt-6-luna. Function calling goes through the Responses API. Chat Completions supports function calling only when reasoning_effort is none. Newer IDs such as gpt-6.1-sol already exist on the API. This Chat release names Sol and Luna. Do not cross the strings.

Structured text is a separate contract. In Responses you set text.format with type json_schema and strict on. That constrains one JSON value in the final text block. It is not the native component set inside Chat. See what Structured Output is.

Answering while thinking also breaks naive parsers. Chat can show an incomplete interface and fill it in later. The first slice of a stream is not a value JSON.parse can take. Structured Outputs on the API still waits until constrained decoding finishes, then you validate the whole object. Do not treat the first card you see in Chat as a sample tool result.

The component library stays inside the product

The library gives each reply a familiar surface. The model decides how the pieces fit. The compiler lets the interface appear before the full reply is done. Training also scored clarity, usefulness, completeness, and when not to add interaction.

That vocabulary lives inside the product. The 7 October post does not publish a JSON Schema for the components, and it does not say a third-party host can reuse the compiler. You cannot validate the component tree in the model’s head, because that tree is not in your response contract. What you can validate is the schema you declared, and the JSON the model actually returned.

Your UI still grows from structuredContent

To put your own interface in ChatGPT, use MCP Apps. Do not imitate the internal format of Intelligent UI. Tools carry inputSchema and outputSchema. Under the 2026-07-28 spec, a missing $schema defaults to JSON Schema 2020-12. structuredContent must match outputSchema. The model and the widget both read it. Large or sensitive data in _meta is for the widget only and does not reach the model. Point the UI at a ui:// resource with _meta.ui.resourceUri. The iframe talks to the host with JSON-RPC over postMessage.

Minimal shape of a to-do result (illustrative — rename fields to match your outputSchema):

{
  "structuredContent": {
    "tasks": [
      {"id": "todo-1", "title": "Split the bill", "completed": false}
    ]
  }
}

Keep the matching outputSchema flat, with every field you read listed in required:

{
  "type": "object",
  "additionalProperties": false,
  "required": ["tasks"],
  "properties": {
    "tasks": {
      "type": "array",
      "items": {
        "type": "object",
        "additionalProperties": false,
        "required": ["id", "title", "completed"],
        "properties": {
          "id": {"type": "string"},
          "title": {"type": "string"},
          "completed": {"type": "boolean"}
        }
      }
    }
  }
}

The spec also says to serialize that same JSON into a text content block, so older clients do not see an empty shell. A render resource such as ui://widget/todo.html belongs only on the tool that actually draws.

Do not pile oneOf and $ref into parameters you plan to run under strict mode. MCP allows the richer 2020-12 vocabulary. Vendor strict mode often does not enforce those keywords, and composition at the schema root can drop the tool from the list with no error. A flat object, a complete required array, and additionalProperties: false is still the shape that survives the model. See why tool calling depends on JSON Schema.

Split data tools from render tools

Hang a widget on every tool and ChatGPT will redraw the iframe over and over. A data tool returns structuredContent only. The render tool carries resourceUri, and its arguments are JSON you have already validated. Numbers the model should narrate go in structuredContent. Secrets, full-page HTML, and widget-only state stay in _meta.

This is not the September API Gateway contract. That gateway turns OpenAPI into tools/list. See why discovery is still JSON. Intelligent UI is the Chat product drawing its own interface. Your tool UI is a different JSON document.

Four JSON documents to check first

  1. outputSchema. Root type object, additionalProperties false, required covering every key you actually read.
  2. One real structuredContent payload. Validate it with that schema. Looking at it and deciding it resembles JSON is not a check.
  3. The text fallback. The text content block is the same object serialized. It is not a second set of field names.
  4. Where resourceUri is attached. Only on the render tool. Do not put secrets in _meta that the model must not see — and must not sit in structuredContent either.

When those four are flat, then decide whether a call should move to gpt-6-sol or gpt-6-luna. A model string does not mint the component library, and it does not repair a result that misses the schema.

Read the contract with local JSON tools

Before you chase the new surface inside ChatGPT, open three texts in the browser: the outputSchema, one structuredContent payload, and the arguments you plan to send to the render tool.

  • JSON Validator — grammar first; with a schema, required keys and extra keys too.
  • JSON Diff — compare the sample behind your outputSchema with the structuredContent the server actually returned.
  • JSON Formatter — spread a one-line tool result, then decide which slice the model should see.

Nothing leaves the browser. Read the contract flat, then change the model string. ChatGPT will draw native components for its own replies. Your field names and required list should stay tight.

FAQ

Can Free users see Intelligent UI today?

The post says Free and Go start on 8 October, powered by GPT-6 Luna. The rollout is staggered, not one minute for every account. Enterprise still depends on the workspace admin switch.

If I set the API model to gpt-6-sol, do I get the same interface?

No. The post describes the Chat tab. The model pages do not publish an Intelligent UI render contract. Tool calling has its own rule: Responses API; Chat Completions only when reasoning_effort is none.

Do structuredContent and the text fallback both need to be written?

Yes. structuredContent is what the model and the widget read. The spec also asks you to serialize that same JSON into a text content block so older clients do not see an empty shell.

Can the model see fields inside _meta?

No. The docs say _meta never reaches the model. Numbers the model should narrate belong in structuredContent.

Is this the same thing as September’s API Gateway MCP?

No. The gateway turns OpenAPI into tools/list. This release is the Chat product drawing its own interface. Your tool UI is a different JSON document.

Should Work and Codex switch models too?

This release says they do not change. Do not copy Chat’s Sol or Luna strings into Work or Codex config.

Summary

Intelligent UI takes over how ChatGPT lays out an answer. It does not take over the JSON contract. Paid Chat uses GPT-6 Sol from 7 October. Free and Go use GPT-6 Luna from 8 October. The component library and the compiler stay inside the product. Your tool result is still structuredContent, held to outputSchema, mirrored in a text block, with the render resource attached only to the tool that draws.

Flatten the schema, a result sample, and the render arguments locally before you change a model string. ChatGPT will draw components for its own replies. The field contract should stay tight.