AI Engineer · Published 2026-09-10

Generative UI... in Python? — Jeremiah Lowin, Prefect

privateReview: unreviewedConfidence: high
MCPpythonreactgenerative-uiprefectprefabfastmcpcode-as-wire-formattoken-efficiencydsl
Open on YouTube ↗

Summary

Overview

  • Speaker: Jeremiah Lowin
  • Channel: AI Engineer
  • Main topic: Building UIs and generative user interfaces using Python via MCP apps and Prefab
  • Purpose: To demonstrate how Python developers can build interactive UIs, MCP apps, and generative UIs using Python-native abstractions without needing full frontend engineering stacks. Jeremiah Lowin discusses the challenge of delivering rich front-end UIs to Python engineers building Model Context Protocol (MCP) servers and agent tools. He introduces Prefab, an open-source UI building framework that allows Python engineers to compose front-ends using Python ergonomics, context managers, and reactive variables, bridging Python backend logic to JSON serialization and React-rendered interfaces.

Topic Map

MCP Apps and Protocol Extension

  • Explanation: Explains how MCP servers traditionally interact with agents and how MCP apps extend this protocol to bypass agents and deliver HTML, CSS, and JavaScript directly to users.
  • Key claims:
    • MCP servers traditionally always go through the brain and context window of an agent.
    • MCP apps allow bypassing the agent to send full HTML/CSS/JavaScript UIs directly to the user.
    • Users can interact directly with applications while agents can also interact with apps in newer MCP releases.
  • Examples:
    • Booking tables, changing flight seats, or playing chess against agents via visual apps.
  • Terminology:
    • MCP (Model Context Protocol)
    • MCP Apps
    • FastMCP
  • Why it matters: It bridges the gap between agent tool results and rich interactive user experiences directly from MCP servers.

The Python Frontend Dilemma & Prefab

  • Explanation: Addresses the challenge that Prefab's user base consists mostly of Python enterprise engineers who need to build UIs and share information without writing React/JavaScript.
  • Key claims:
    • Python engineers do not need consumer-grade custom branded UIs; they need data sharing and collection tools.
    • Prefab is a scoped UI building framework for delivering UIs through agents using Python ergonomics.
  • Examples:
    • Building data tables, forms, and charts entirely in Python using Prefab.
  • Terminology:
    • Prefab
    • Python DSL
    • Context managers
  • Why it matters: Enables Python developers to compose production-ready UIs using familiar language constructs.

Prefab Pipeline: Python to JSON to React

  • Explanation: Breaks down the architecture of Prefab where a Python DSL compiles to a declarative JSON protocol, which is then rendered by a React-based MCP app client.
  • Key claims:
    • Python DSL creates a declarative UI representation.
    • The representation serializes into a streamable, agent-friendly JSON protocol.
    • A React app hosted on the MCP client renders the final interactive application.
  • Examples:
    • Using python context managers for component nesting that maps directly to UI element trees.
  • Terminology:
    • JSON protocol
    • React app
    • Reactive variables
  • Why it matters: Provides an efficient intermediate serializable representation that both agents and clients can consume.

Three Ways to Use Prefab with MCP Servers

  • Explanation: Details interactive tools, FastMCP apps, and generative UI capabilities within Prefab.
  • Key claims:
    • Interactive tools return Prefab components from an MCP tool instead of basic data dictionaries.
    • FastMCP Apps use the MCP server as an application backend with entrypoints and tools.
    • Generative UI allows agents to stream UI definitions dynamically over the wire.
  • Examples:
    • Returning a DataTable component directly from a FastMCP tool decorated function.
    • Streaming Claude-generated UI components in real time.
  • Terminology:
    • Interactive tools
    • FastMCP Apps
    • Generative UI
  • Why it matters: Gives developers scalable patterns ranging from simple one-shot UI tools to fully agent-generated UIs.

Key Points

Composing UIs in Python

  • Explanation: Prefab lets developers build user interfaces using Python classes as components, context managers for layouts, and reactive variables for state.
  • Evidence: Code snippets showing with Card(): with Column(): DataTable(...).
  • Practical implication:

Python vs JSON Token Efficiency

  • Explanation: Python representations of UIs are significantly more compact than JSON representations.
  • Evidence: Speaker notes Python representations are about 70% smaller than JSON representations.
  • Practical implication: Streaming Python to be evaluated and compiled into JSON on the server side provides massive token efficiency and latency benefits.

Frameworks, Models & Processes

Prefab

  • How it works: Uses a Python DSL and context managers to compose declarative UI components, serializes them into a JSON protocol, and renders them via a React client.
  • Components:
    • Components as classes
    • Layout via context managers
    • State via Rx variables
  • When to use: When Python engineers need to build interactive UIs, tools, or MCP apps without writing React/frontend code.

FastMCP

  • How it works: A Python framework for building MCP servers using decorators to expose tools and functions to AI agents.
  • Components:
    • FastMCP server instance
    • Tool decorators
    • App provider integrations
  • When to use: When developing MCP servers in Python and extending them with interactive UI tools and apps.

Examples & Case Studies

Returning a DataTable from a FastMCP tool function instead of a Python dictionary.

  • Illustrates: Interactive MCP tools
  • Lesson: FastMCP automatically infers that a Prefab component is being returned and spins up the necessary HTML/JS/CSS rendering.

Asking Claude to stream the most interesting UI possible during a live demo.

  • Illustrates: Generative UI with MCP
  • Lesson: Agents can dynamically stream UI serialization protocols over MCP tools to render complex dashboards instantly.

Actionable Takeaways

  • Immediate:
    • Check out Prefab documentation at prefab.prefect.io
    • Install optional Prefab components in FastMCP
  • Strategic:
    • Composing frontends in Python is viable and efficient when constrained to composition over building from scratch
    • Streaming Python code over the wire instead of raw JSON provides significant token efficiency and latency advantages
  • Questions to investigate:
    • How do reactive variables handle complex bidirectional client-server state synchronization?
    • What are the security implications of executing streamed Python code in sandboxed server environments?

Claims Worth Verifying

  • Python UI representations are about 70% smaller than JSON representations. (Performance/Efficiency Claim)

Notable Quotes

"MCP apps are an extension of the MCP protocol that was introduced I think in January of this year." (at 0:56) "Composing frontends in Python is surprisingly natural." (at 10:05)

Compressed Summary

  • MCP apps allow bypassing the agent to deliver full HTML/CSS/JS user interfaces directly to users.
  • Prefab provides a Python DSL for composing UIs using classes, context managers, and reactive variables.
  • Prefab serializes Python UI code into a JSON protocol rendered by a React client.
  • FastMCP integrates Prefab components seamlessly into MCP server tools and applications.
  • Streaming Python to the server to compile into JSON offers major token efficiency over streaming raw JSON.
  • Keywords: mcp, python, react, generative-ui, prefect
  • Core insight: Python developers can build rich, interactive, and generative UIs for MCP servers by composing existing components using Python ergonomics through frameworks like Prefab.

Core insights

6
Architecturehigh noveltystrong evidence

MCP apps turn UI rendering into a protocol-level capability: an MCP server can emit HTML/CSS/JS directly to the user, bypassing the agent's context window entirely, while tool-style interaction with the same app remains available in newer MCP releases.

Why it matters

It decouples UI richness from token budget and from the agent's reasoning loop. A dashboard can be arbitrarily large and interactive without ever being serialized into an agent's context, which changes cost, latency, and what a 'tool result' even is.

Generalization

When a payload's only consumer is a human, route it around the model; reserve context-window bandwidth for data the model must actually reason over.

MCP servers traditionally always go through the brain and context window of an agent.
Open source video
MCP apps allow bypassing the agent to send full HTML/CSS/JavaScript UIs directly to the user.
Open source video
Users can interact directly with applications while agents can also interact with apps in newer MCP releases.
Open source video
Mechanismmedium noveltystrong evidence

Prefab's pipeline is a three-stage boundary: a Python DSL (classes as components, context managers for nesting, reactive variables for state) compiles to a declarative, streamable JSON protocol, which a React client renders. The JSON is the contract; Python and React are two independent authoring/rendering frontends over it.

Why it matters

The intermediate representation is what makes the system agent-friendly: it is incremental/streamable and client-renderable, so an agent can emit partial UI and have it appear progressively. It also lets Python-side ergonomics evolve without changing the renderer.

Generalization

Separating an authoring surface (convenient, developer-facing) from a wire IR (streamable, machine-consumable) from a render runtime is a reusable pattern for any generated-artifact system.

Python DSL creates a declarative UI representation.
Open source video
The representation serializes into a streamable, agent-friendly JSON protocol.
Open source video
A React app hosted on the MCP client renders the final interactive application.
Open source video
Tradeoffhigh noveltyweak evidence

Python is claimed to be roughly 70% more compact than JSON as a UI wire format, suggesting a code-as-wire-format pattern: the agent streams Python, the server evaluates and compiles it to JSON, and the client renders the JSON.

Why it matters

If the compaction holds, it directly reduces token cost and time-to-first-render for generative UI, and shifts a compilation step onto a trusted server. It is also the most load-bearing quantitative claim in the talk and is unevidenced beyond the speaker's assertion.

Generalization

For agent-generated structured artifacts, shipping a compact DSL and compiling at the receiver can beat shipping the expanded serialization, at the price of moving executable input into the trust boundary.

Speaker notes Python representations are about 70% smaller than JSON representations.
Open source video
Streaming Python to be evaluated and compiled into JSON on the server side provides massive token efficiency and latency benefits.
Open source video
Practicemedium noveltystrong evidence

There is a three-tier adoption ladder for UI in MCP servers: (1) interactive tools that return a component instead of a data dictionary, (2) FastMCP apps that treat the MCP server as an application backend with entrypoints and tools, (3) generative UI where the agent streams UI definitions over the wire at runtime.

Why it matters

Tier 1 is a near-zero-migration upgrade from existing tool code (the decorated function returns a component; the framework infers the rendering path), letting teams get interactive output without adopting agent-generated UI or a new backend model. Tier 3 is the highest-variance option and should be adopted last.

Generalization

Introduce generative interfaces incrementally: first upgrade the return type at an existing boundary, then change the backend model, then hand composition authority to the model.

Interactive tools return Prefab components from an MCP tool instead of basic data dictionaries.
Open source video
FastMCP Apps use the MCP server as an application backend with entrypoints and tools.
Open source video
Generative UI allows agents to stream UI definitions dynamically over the wire.
Open source video
FastMCP automatically infers that a Prefab component is being returned and spins up the necessary HTML/JS/CSS rendering.
Open source video
Mental Modelmedium noveltymoderate evidence

The framework is deliberately scoped to a bounded catalog of pre-built components (tables, forms, charts) aimed at enterprise data sharing and collection, explicitly not consumer-grade custom branded UI. Viability comes from composition over building from scratch.

Why it matters

Constraining the output space to a fixed component vocabulary is what makes model-generated UI tractable: the agent selects and nests known components rather than authoring arbitrary frontend code, which bounds correctness, styling, and review surface.

Generalization

Generative UI reliability scales inversely with output-space freedom; a curated component registry functions like a grammar for the model's rendering output.

Python engineers do not need consumer-grade custom branded UIs; they need data sharing and collection tools.
Open source video
Prefab is a scoped UI building framework for delivering UIs through agents using Python ergonomics.
Open source video
Composing frontends in Python is viable and efficient when constrained to composition over building from scratch
Open source video
Mechanismlow noveltymoderate evidence

Python's ergonomics for UI composition come from mapping language constructs onto UI semantics: classes become components, context managers become the element tree / nesting, and reactive variables become state.

Why it matters

It explains why the DSL is compact and readable, and it identifies where the hard problems land: nesting is solved syntactically, but state (reactive variables) is the part with unresolved client-server synchronization semantics.

Generalization

Declarative UI DSLs port well when the host language already has structural analogues for hierarchy (scopes/blocks) and identity (objects); state synchronization is the part that rarely ports cleanly.

Prefab lets developers build user interfaces using Python classes as components, context managers for layouts, and reactive variables for state.
Open source video
with Card(): with Column(): DataTable(...)
Open source video

Deep dives

5

Trust boundary of code-as-wire-format: evaluating streamed Python before it becomes JSON

Research question

Can an allowlisted, parse-don't-eval subset of the Prefab DSL preserve the reported token and latency savings of shipping Python instead of JSON while eliminating arbitrary server-side execution of model-generated code?

Why

The token-efficiency argument is the most load-bearing quantitative claim in the talk, and it only works if the server compiles streamed code. That single design choice moves executable model output inside the trust boundary. If a parse-only AST validator over a fixed component vocabulary captures most of the compaction, the security cost of the pattern is avoidable and the pattern becomes adoptable; if it does not, every adopter inherits an arbitrary-code-execution surface.

Speaker notes Python representations are about 70% smaller than JSON representations.
Open source video
Streaming Python to be evaluated and compiled into JSON on the server side provides massive token efficiency and latency benefits.
Open source video
The representation serializes into a streamable, agent-friendly JSON protocol.
Open source video
Source video

The agent's blind spot: what is lost when UI bypasses the context window

Research question

After a user interacts directly with an MCP app that the agent previously produced, can the agent correctly answer follow-up questions about the mutated state without an explicit state re-surfacing channel?

Why

Bypassing the agent is the headline benefit, but it creates a divergence between what the agent believes it produced and what the user is now looking at. Unless the framework defines a state-reporting path back into context, every direct manipulation inside the app silently invalidates the agent's model of the world. This determines whether the dual-channel tool result is a clean separation of concerns or a correctness bug.

Users can interact directly with applications while agents can also interact with apps in newer MCP releases.
Open source video
MCP apps allow bypassing the agent to send full HTML/CSS/JavaScript UIs directly to the user.
Open source video
MCP servers traditionally always go through the brain and context window of an agent.
Open source video
Source video

Reactive variables as a distributed state problem hidden inside a Python DSL

Research question

What synchronization protocol and conflict-resolution semantics are required for reactive variables to stay coherent across the Python author, the JSON protocol, and the React renderer under concurrent multi-client interaction?

Why

Layout and nesting port cleanly onto context managers, but state does not port cleanly across a process boundary. Reactive variables are presented as an ergonomic win, yet they relocate the hardest part of any interactive system -- bidirectional convergence -- into the serialization layer. Without defined ordering and conflict behavior, the ergonomics are borrowed against undefined runtime behavior.

Prefab lets developers build user interfaces using Python classes as components, context managers for layouts, and reactive variables for state.
Open source video
The representation serializes into a streamable, agent-friendly JSON protocol.
Open source video
A React app hosted on the MCP client renders the final interactive application.
Open source video
Source video

Measuring Python-versus-JSON wire compaction net of compile overhead

Research question

Does the claimed ~70% payload reduction of a Python DSL over equivalent JSON hold across tokenizers and UI complexity tiers, and does it still produce a faster time-to-first-render once the server-side compile step is included?

Why

The number is an unqualified speaker assertion with no baseline, tokenizer, or corpus. Because it is the justification for the entire code-as-wire-format architecture, it needs to be decomposed: gross token savings, compile latency cost, and net user-perceived latency. A gross win with a net loss would invert the design recommendation.

Speaker notes Python representations are about 70% smaller than JSON representations.
Open source video
Streaming Python to be evaluated and compiled into JSON on the server side provides massive token efficiency and latency benefits.
Open source video
The representation serializes into a streamable, agent-friendly JSON protocol.
Open source video
Source video

The component catalog as a grammar for model-generated interfaces

Research question

How much of generative-UI render reliability is attributable to restricting the output space to a curated component registry rather than to model capability or prompt engineering?

Why

If reliability scales inversely with output-space freedom, the engineering priority shifts from better prompting to tighter schema design and validation at the protocol boundary before render. This reframes 'generative UI' from an open-ended code-generation problem into a constrained selection-and-nesting problem, which changes how the system is tested and reviewed.

Python engineers do not need consumer-grade custom branded UIs; they need data sharing and collection tools.
Open source video
Composing frontends in Python is viable and efficient when constrained to composition over building from scratch
Open source video
Generative UI allows agents to stream UI definitions dynamically over the wire.
Open source video
Source video

Article ideas

4

Your Tool Results Should Not Fit in the Context Window

Once a server can emit a rendered UI directly to a human, the single tool-result contract splits permanently into two channels -- model-facing data and human-facing interface -- and teams that keep serializing dashboards into context windows are paying for tokens the model never needed to reason over.

Angle

Argue from the context-window cost model rather than from UI aesthetics: complexity of the interface becomes independent of agent cost, which forces a redefinition of what a tool result is and what the agent is expected to observe.

Source video

Code Is a Better Wire Format Than JSON -- Until You Have to Execute It

Shipping a compact Python DSL and compiling at the receiver is a genuinely better token and latency economics story than shipping expanded JSON, but the gain is purchased by moving executable model output inside the trust boundary; the only defensible version of the pattern is an allowlisted parse-don't-eval compiler over a fixed component vocabulary.

Angle

Quantify the trade rather than pick a side: measure the compaction, then measure how much of it survives when the receiver can only parse a validated subset of the DSL. Treat the compile step as the architectural decision, not the payload size.

Source video

The Component Registry Is the Grammar of Generative UI

Generative UI quality is bounded less by model capability than by how tightly the output space is constrained; a curated catalog of tables, forms, and charts turns an unbounded frontend code-generation problem into a selection-and-nesting problem with a reviewable, testable surface.

Angle

Reframe reliability as a schema-design problem: name the failure modes of unconstrained generation, then show why registry restriction and protocol-boundary validation are the levers that actually move render success rates.

Source video

Adopt Generated Interfaces in Three Steps, Not One

The migration path to generative UI has a natural risk ordering -- change a tool's return type first, change the server's role second, hand composition authority to the model last -- and teams that invert that order absorb the highest-variance change before they have the instrumentation to detect its failures.

Angle

Frame the adoption ladder as a risk-management sequence, with the tier-1 upgrade presented as near-zero-migration and tier-3 as the last thing anyone should ship.

Source video

Project ideas

4

Wire-Format Bake-Off

beyond-evals

An identical set of UIs expressed as a Python DSL yields 40-70% fewer tokens than the equivalent JSON payload across at least two tokenizers, and still achieves lower time-to-first-render once server-side compile latency is included, for UIs above a threshold complexity where the compile step amortizes.

Proof of concept

Encode 20 reference UIs (tables, multi-section forms, nested charts) in both Prefab-style Python DSL and hand-written JSON; measure token counts under multiple tokenizers, compile time, payload bytes, and simulated time-to-first-render across tiers of UI complexity from 3 components to 50.

Measurement

Token ratio (Python/JSON) per tokenizer and per complexity tier, with confidence intervals; compile overhead in ms; net time-to-first-render delta; the complexity threshold at which net latency flips positive.

Source video

Parse-Don't-Eval Gate

gatehouse

An AST-allowlist validator restricted to the component DSL grammar rejects 100% of injected or out-of-vocabulary constructs while retaining at least 90% of the token savings of full evaluation and producing byte-identical rendered JSON for all valid inputs.

Proof of concept

Build a compiler that parses streamed Python into an AST, validates it against a fixed component/context-manager/reactive-variable allowlist with no attribute access, imports, or calls outside the registry, and emits the JSON protocol. Fuzz it with a corpus of adversarial snippets and compare output fidelity against a full-eval reference on valid inputs.

Measurement

Adversarial rejection rate (target 100%), false-rejection rate on a valid-UI corpus, token-savings retention versus full evaluation, output equivalence rate on valid inputs, and added compile latency.

Source video

Ghost State Probe

movement-lab

Agents asked follow-up questions about a UI they generated will answer incorrectly after the user edits that UI in-app, unless app state is explicitly re-surfaced into context; re-surfacing a compact state delta restores accuracy to near the no-edit baseline at a fraction of the token cost of full re-serialization.

Proof of concept

Instrument an MCP app where an agent produces a data table with a form; have a user make N edits directly in the app; then ask the agent K state-dependent questions under three conditions: no re-surfacing, full state re-serialization, and a compact delta channel.

Measurement

Answer accuracy per condition, tokens consumed per condition, and the accuracy-per-token frontier; count of confidently wrong answers as the primary harm metric.

Source video

Divergence Harness

new

Reactive variables without an explicit conflict-resolution protocol produce observable client/server state divergence in more than 10% of concurrent two-client edits to the same component within a sub-second window, and divergence rate scales with edit overlap rather than with payload size.

Proof of concept

Stand up a Prefab-style app with a two-client concurrent-edit scenario over a shared table and form; replay scripted interleavings with controlled latency and ordering; snapshot state at Python author, JSON protocol, and React renderer layers after each interleaving and diff them.

Measurement

Divergence rate as a function of overlap window and network latency; time-to-convergence or permanent divergence; whether last-write-wins ordering differs across the three layers.

Source video

Architectural implications

4

UI output moves from an agent-mediated artifact to a direct server-to-client channel.

Before

Every MCP tool result had to be routed through the agent's brain and context window before a user saw anything.

After

MCP apps deliver full HTML/CSS/JS payloads straight to the user, with agent interaction as a separate, optionally coexisting path.

Consequence

Context-window cost becomes independent of interface complexity; new questions arise about what the agent can observe from user interactions inside the app.

Source video

The frontend responsibility boundary shifts from frontend engineers to backend Python authors, with React demoted to a generic renderer.

Before

Delivering a rich UI required React/JavaScript engineering capacity.

After

The Python author composes components; a JSON protocol is produced; a React MCP-app client renders it.

Consequence

The renderer becomes a stable, shared runtime that must be versioned against the protocol, and the DSL becomes the actual product surface.

Source video

The tool return contract expands from data to interface.

Before

A FastMCP tool returned a Python dictionary of data.

After

The tool returns a Prefab component and the framework infers the rendering path and generates the HTML/JS/CSS.

Consequence

Tools can now carry layout and interaction semantics, so tool signatures, versioning, and testing must cover presentation, not just data correctness.

Source video

Generative UI makes the component schema part of the model's output space.

Before

The agent produced text and selected tools; presentation was fixed by the client.

After

The agent streams UI definitions that are rendered as a live application.

Consequence

Prompt/schema design for the component vocabulary becomes a first-class reliability lever, and validation must happen at the protocol boundary before render.

Source video

Tradeoffs and failure modes

4

Python-as-wire-format versus JSON-as-wire-format

Benefit

Reported ~70% smaller payloads, plus lower latency and token cost when streaming UI to a client.

Cost or risk

Requires evaluating streamed code server-side, which introduces an execution trust boundary that a pure JSON payload does not have; the compaction figure is unverified and may not generalize across UI shapes.

Streaming Python to be evaluated and compiled into JSON on the server side provides massive token efficiency and latency benefits.
Open source video
Source video

Bypassing the agent for rendering

Benefit

Rich, interactive UIs reach users without consuming context tokens or agent turns.

Cost or risk

The agent is out of the loop for direct user interactions unless the newer MCP interaction path is used, creating a possible observability/awareness gap and coordination problems between app state and agent state.

Users can interact directly with applications while agents can also interact with apps in newer MCP releases.
Open source video
Source video

Scoped component catalog

Benefit

Composition over creation makes Python-authored UI viable and keeps generated output bounded and predictable.

Cost or risk

Ceiling on expressiveness: no consumer-grade custom branded UI, so product-facing or design-heavy surfaces fall outside the framework.

Python engineers do not need consumer-grade custom branded UIs; they need data sharing and collection tools.
Open source video
Source video

Reactive state across the Python/JSON/React boundary

Benefit

Reactive variables let Python code express interactive state declaratively alongside layout.

Cost or risk

Bidirectional client-server synchronization semantics are not settled, so round-trip state can desynchronize or behave unpredictably under concurrent interaction.

How do reactive variables handle complex bidirectional client-server state synchronization?
Open source video
Source video

Open questions

4

Is the claimed ~70% size reduction of Python versus JSON UI representations robust across realistic UIs and tokenizers?

Why unresolved

The figure is a single speaker assertion with no described measurement, baseline, or UI corpus.

Research direction

Benchmark identical Prefab UIs serialized as Python DSL versus JSON, measuring tokens under multiple tokenizers and across UI complexity tiers, plus end-to-end time-to-first-render.

Source video

How do reactive variables synchronize state bidirectionally between the client app and the Python server without divergence?

Why unresolved

The talk presents reactive variables as a state mechanism but leaves the synchronization protocol and conflict behavior unaddressed.

Research direction

Build a two-client concurrent-edit scenario over a Prefab app and characterize update ordering, conflict resolution, and latency.

Source video

What is the security model for evaluating model-generated Python on the server before it becomes JSON?

Why unresolved

The token-efficiency argument implies server-side evaluation of streamed code, but no sandboxing or capability restriction is described.

Research direction

Threat-model the compile step, test an allowlisted subset of the DSL (parse-don't-eval) as a safer alternative, and compare token savings against the safety loss.

Source video

What does the agent lose when the UI bypasses its context window?

Why unresolved

The summary distinguishes direct user interaction from agent interaction with apps but does not describe how app state is surfaced back to the agent.

Research direction

Instrument an MCP app where the user edits a table the agent previously produced, and measure whether the agent can correctly answer follow-up questions about the edited state.

Source video

Key claims

7
factualVerification needed

MCP servers traditionally route all results through the agent's context window.

Evidence

MCP servers traditionally always go through the brain and context window of an agent.

Question

Does the baseline MCP specification provide any server-to-client rendering path absent an agent turn?

Source video
causalVerification needed

MCP apps let a server send full HTML/CSS/JS UI directly to the user, bypassing the agent.

Evidence

MCP apps allow bypassing the agent to send full HTML/CSS/JavaScript UIs directly to the user.

Question

What are the transport, trust, and sandboxing constraints on server-delivered HTML/JS in MCP clients?

Source video
comparativeVerification needed

Python UI representations are about 70% smaller than equivalent JSON representations.

Evidence

Speaker notes Python representations are about 70% smaller than JSON representations.

Question

Measured under what tokenizer, over what set of UIs, and does the gap persist net of the extra compile step?

Source video
factualVerification needed

Prefab serializes a Python UI DSL into a streamable JSON protocol rendered by a React client.

Evidence

The representation serializes into a streamable, agent-friendly JSON protocol.

Question

Is the protocol genuinely incremental (partial-render capable) or only delivered as one payload?

Source video
factualVerification needed

Returning a Prefab component from a FastMCP tool causes the framework to infer rendering and generate HTML/JS/CSS automatically.

Evidence

FastMCP automatically infers that a Prefab component is being returned and spins up the necessary HTML/JS/CSS rendering.

Question

How does inference behave when a tool returns a mixed or nested structure, and what is the fallback?

Source video
causalVerification needed

Agents can stream UI definitions dynamically over the wire to produce rendered applications at runtime.

Evidence

Generative UI allows agents to stream UI definitions dynamically over the wire.

Question

What failure rate do streamed UI definitions show under invalid nesting, unknown components, or truncated streams?

Source video
opinionVerification not requested

Composing frontends in Python is natural for developers already working in Python.

Evidence

Composing frontends in Python is surprisingly natural.

Source video

Connections

5