OpenAI is building an interface platform inside ChatGPT
The internal widget architecture can refresh interfaces inside conversations, with 467 module manifests spanning physics, finance, cooking and CPR.
By Ryan Merket · Published · Updated
RUNTIMEWIRE INVESTIGATION — Scoop
Original reporting by RuntimeWire, based on reverse engineering.
Why it matters
Embedding task-specific software directly in answers can keep users inside ChatGPT instead of sending them to standalone tools and websites. Because the current architecture is closed and first-party, OpenAI controls which interfaces receive distribution while outside developers lack a comparable route. That makes the client and interface layer another source of lock-in beyond model quality.
Reporting record
Finding
OpenAI’s Codex desktop client contains an undocumented GenUI architecture capable of delivering structured conversational interfaces, alongside a locally bundled catalog of 467 versioned “Learning Block” types.
How we verified
Methods: reverse engineering.
RuntimeWire independently extracted and analyzed the signed Windows distribution of OpenAI’s Codex desktop client. The package contains a 1.09 MB Learning Block runtime with 442 embedded manifests representing 467 unique type-and-version combinations. The client describes these objects to users as “Interactive learning block[s]” and includes dedicated rendering, control, caption, example, analytics and error-handling systems. Recovered metadata includes matched_type, server_learning_block_version, rendered_learning_block_version, initial_values, thumbnail_asset_key, widget_type and display_mode. Separate application code exposes a generic genui message type and an authenticated endpoint at: /conversation/{conversation_id}/message/{message_id}/genui/refresh_widget The associated client operation is named refreshGenUiWidget, with genui_refresh metadata. The code can also reinterpret a generic GenUI payload as a charts_widget_v2, indicating that GenUI is a broader delivery layer rather than another name for Learning Blocks. Learning Blocks identify their default render source as: CHATGPT_MATH_BLOCK_RENDER_SOURCE_GENUI_LEARNING_BLOCK This establishes the relationship supported by the code: GenUI is the underlying interface architecture, while Learning Blocks are a first-party family of interactive modules delivered through it. The package includes explicit fallback reasons—missing_matched_type, unsupported_matched_type and external_egress_blocked—showing that the server selects a block type and the client renders it only when the necessary local implementation and permissions are available. RuntimeWire found 901 visualization-related JavaScript chunks and 552 example-related chunks. Those numbers describe compiled files, not unique products. The defensible catalog count is 467 unique versioned types, recovered from the manifests themselves. Public OpenAI documentation describes the currently available Visualize feature, but does not document the GenUI name, its refresh endpoint, the Learning Blocks registry or the scale of the bundled catalog.
1. Parsed the supplied Codex `app.asar` without modifying the signed installation. 2. Verified its cryptographic hash against the installed package. 3. Indexed the webview assets. 4. Located the generic GenUI request and refresh paths. 5. Traced generic `genui` references into recognized widget types. 6. Identified the explicit `GENUI_LEARNING_BLOCK` source value. 7. Followed the Learning Block content-reference renderer. 8. Extracted the Learning Block manifest registry. 9. Mapped minified manifest variables back to 467 unique identifiers. 10. Counted manifest versions. 11. Recovered subject-group labels. 12. Traced visualization, controls, captions, thumbnails and examples. 13. Examined fallback, analytics, feedback and follow-up behavior. 14. Compared the findings with OpenAI’s public description of Visualize. 15. Separated confirmed client behavior from claims requiring server-side evidence.
Tested versions: Windows package: `OpenAI.Codex_26.820.7780.0_x64__2p2nqsd0c76g0` Internal application version: `26.820.60940` Build: `7119`.
Reproduction
RuntimeWire independently reproduced the core finding.
Obtain the same signed Codex Windows package. Record the SHA-256 digest of app/resources/app.asar. Copy the archive to a separate analysis directory. Extract it using an Electron-compatible ASAR utility. Locate webview/assets/learning-block-Cr6UKzy-.js. Parse the embedded manifests and deduplicate entries by their type and version fields. Confirm 467 unique type/version combinations. Search the remaining compiled bundles for:- refreshGenUiWidget - genui_refresh - /genui/refresh_widget - charts_widget_v2 - CHATGPT_MATH_BLOCK_RENDER_SOURCE_GENUI_LEARNING_BLOCK - missing_matched_type - unsupported_matched_type - external_egress_blocked Preserve screenshots, extracted strings, parsing output and hashes as the reporting record. Do not modify the installed or signed application.
File hashes
5DF8BF5A9D30742919390AB11FA419E83AAB0891152569A42C6EA4ABF15386C2
Company response
RuntimeWire requested comment; the company had not responded by publication time.
OpenAI has built a generalized system for delivering interactive interfaces inside conversations, according to a RuntimeWire examination of code bundled with the Codex desktop client. The architecture is identified as GenUI in OpenAI's internal plumbing and includes a catalog of 467 versioned manifests for interactive modules known as Learning Blocks.
The finding puts deeper infrastructure behind OpenAI's publicly documented Visualizations preview. The public feature turns prompts and source material into charts, maps, diagrams, calculators, simulations and other interactive explanations. OpenAI says Visualize is available to supported accounts on the web and is rolling out across its desktop and mobile apps.
The Codex client shows how OpenAI may deliver some of those experiences. It recognizes structured conversation objects with the generic type genui, associates them with individual messages and can request updated widget data through a dedicated endpoint:
/conversation/{conversation_id}/message/{message_id}/genui/refresh_widget
The corresponding client method is named refreshGenUiWidget. It can continue polling while an interface is incomplete and stop after the server marks the object complete. OpenAI's published data analytics instructions separately refer to a charts_widget_v2 interface delivered through a live genui content reference, corroborating that GenUI extends beyond a single lesson renderer.
Learning Blocks show the system at scale
Learning Blocks appear to be one first-party application running on this broader delivery layer. The Codex package explicitly identifies their render source as CHATGPT_MATH_BLOCK_RENDER_SOURCE_GENUI_LEARNING_BLOCK and maintains a separate registry of components, manifests, parameter schemas, controls, captions, thumbnails, examples and follow-up prompts.
RuntimeWire recovered 467 unique manifests from that registry. Of those, 181 are marked version 1, 217 are version 2, 59 are version 3, nine are version 4 and one is version 5. Those numbers count unique module manifests rather than every built JavaScript file shipped with the client.
The catalog reaches far beyond the mathematics suggested by the older CHATGPT_MATH_BLOCK_TYPE_ engineering namespace. Academic modules cover projectile motion, acid-base titration, DNA transcription, Bayes' theorem, supply and demand, Dijkstra's shortest-path algorithm and nuclear fission.
Other blocks teach practical and physical tasks, including dicing an onion, rolling sushi, using chopsticks, applying caulk, tying knots, shooting a basketball layup and performing a freestyle swimming stroke. Catalog entries also reference adult CPR and AED sequencing, surgical hand scrubbing, sterile gloving, suturing and surgical-knot techniques. Their presence does not establish that these modules are enabled, medically validated or intended for public release.
The breadth turns Learning Blocks into an interactive knowledge catalog rather than a collection of chart templates. A server can specify a module, its version and initial values; the client then finds the packaged implementation and loads the requested state. That arrangement gives OpenAI tighter control over behavior and presentation than generating each interface from scratch.
The client does not identify which server component selects a Learning Block. The choice could come from a language model, a classifier or another routing service. The code also does not establish that every recovered module is active or available to users.
An interface layer for answers
GenUI's generic routing and refresh behavior is the more consequential part of the package. It gives OpenAI a common mechanism for replacing sections of a written answer with software tailored to the task: a chart for a dataset, a simulation for a physics question or a guided sequence for a procedure.
Learning Blocks are structured as a distinct subsystem within that mechanism. Each reference can carry fields including matched_type, server_learning_block_version, initial_values, thumbnail_asset_key, widget_type, display_mode and source. The client also records rendering, interactions, feedback and view state.
The architecture resembles the emerging "generative UI" model now being publicly developed elsewhere in the industry. Flutter's GenUI SDK, for example, lets an AI agent select and compose interfaces from a developer-defined widget catalog. OpenAI's implementation appears more closed: its servers select objects understood by its own clients, while Learning Blocks provide a large first-party catalog. RuntimeWire found no evidence that OpenAI uses Flutter's SDK or the A2UI protocol beneath it.
The shared GenUI name may be descriptive industry shorthand rather than a unique OpenAI codename. "Learning Blocks" is the more distinctive internal name; "GenUI" identifies the architectural category and OpenAI's internal plumbing.
That architecture resembles a closed internal application platform. OpenAI supplies the host, routing infrastructure and packaged interfaces. The client code does not establish a public GenUI product, developer SDK, marketplace or a way for outside developers to register widgets.
Visualize may be a public-facing capability built on GenUI or an adjacent system, but the relationship cannot be confirmed from the client alone. OpenAI's documentation focuses on what users can request and where the preview runs. The Codex package exposes the lower-level machinery: structured content references, server-directed routing, refreshable state and multiple recognized widget families.
RuntimeWire examined Windows package OpenAI.Codex_26.820.7780.0_x64__2p2nqsd0c76g0. The application archive's SHA-256 was 5DF8BF5A9D30742919390AB11FA419E83AAB0891152569A42C6EA4ABF15386C2. The 1,088,680-byte Learning Block bundle's SHA-256 was AA055ADAF4150295A106B9E1AA33757AE5C97E79A8DFC144CED9794C8522E942.
The package version is also identified in reports on OpenAI's official Codex repository. RuntimeWire parsed the installed application's archive and indexed its webview assets. The Learning Block registry was contained in webview/assets/learning-block-Cr6UKzy-.js.
RuntimeWire sent OpenAI detailed questions at 7:57 p.m. PT on August 26th and requested a response by 8:07 p.m. PT. OpenAI did not respond before publication. This article will be updated if the company responds.
The 467 bundled manifests reveal a substantial client-side application layer already under development. GenUI points toward a version of ChatGPT where an answer can arrive as an interface selected for the problem at hand, although the package does not establish which blocks are active or when they might reach users.