GenUI with Jev

Generative user interfaces (GenUI) can be accelerated using System-One models like Jev. Instead of generating layouts token by token, Jev determines the structure, data, and UI components in just a few milliseconds.

You’re looking for the contact form on a website. Instead of navigating, you simply type, “I’d like to contact the company”—and the appropriate input form appears immediately.

Approaches like this simplify the use of websites and change the way we interact with digital services.

Generative UI made easy.

Since the release of Jev, a System-One model from TypeSafe AI, there have been many posts on social media testing potential use cases for this type of AI.

In our experiment—a GenUI pipeline—Jev determines the layout, data set, and displayed fields of a UI component with a single call, and the component was fully rendered in 250 to 350 milliseconds.

To learn how we did this, you can jump directly to “GenUI Pipeline with Jev”.

What is GenUI?

Generative UI (GenUI) refers to dynamic user interfaces that adapt precisely to the intent and context of a user’s query in real time. Instead of a text-only response, users receive appropriate interaction and UI components such as contact forms, map carousels, or intuitive input fields.

Previous approaches have mostly relied on traditional language models (LLMs) to directly generate desired interfaces—but this leads to three key challenges:

• Wait time. Since LLMs generate only token by token, it takes longer for more complex components.

• Made-up facts. Language models often invent content they cannot find.

• Lack of control. Generated structures may not be processable.

Our pipeline solves these problems with the help of Jev, since our model only makes decisions and does not actually generate content.

What is a System-One model?

A System-One model is an AI model that makes decisions based on calculated probabilities rather than generating free-form text. It populates predefined formats such as selection options, yes/no statements, or scale values. Since the text isn’t generated token by token, the response time is significantly shorter than with traditional language models. Jev thus quickly determines: What is needed, which data fits, and which UI component is suitable for the task?

GenUI Pipeline with Jev.

In an efficient GenUI architecture, Jev handles all decisions regarding UI components in a single request, while the actual rendering is performed by traditional program code.

1. 1

   Preselection: Code sorts the entries in the directory.

2. 2

   A Jev call: Jev answers multiple questions in a single pass: What do users want? What data do we need for that? A single result or a list? Which UI component is the right one? Which fields should I display?

3. 3

   Rendering: The component is then loaded in the code, populated with the selected information from the database, and validated.

Since the Jev call is the only network request before the first paint, we reduce latency to a minimum. The System-One model answers all questions in a single call, without the answers being dependent on one another, which is why more data does not mean longer wait times.

Is Jev a good model?

Ultimately, Jev only provides priority lists that the code interprets. The answer lies in the infrastructure built around it. This is how we generate a layout based on Jev’s classifications without losing verifiability. The following building blocks are relevant for this:

Component Registry. Each component is indexed exactly once and described by UX/UI experts. These descriptions form the basis for the questions, the validation scheme, and the renderer. New components simply need to be registered and are processed directly by the model.

Layout Grammar. Fixed rules define which and how many components are allowed in different UI areas. For example, a contact form has exactly one heading, one to five input fields, and one to two buttons.

Fallback solutions. If the first choice is too uncertain (< 60% confidence), the pipeline gradually reverts to:

1. 1

   A pre-built UI component with data for all required fields

2. 2

   Freely assembled smaller UI building blocks that match the intended purpose

3. 3

   A simple list of facts to answer the query

4. 4

   A follow-up query if none of the three options worked reliably

How could System-One models change the UI?

Generative UI becomes faster and more reliable through System-One models. If this pattern proves successful, models that generate responses from known datasets could provide interaction and information interfaces optimally tailored to user intent. The question would then no longer be “What should I write?” but “What should I show?”

Whether this idea is feasible with large amounts of data would need to be proven through larger-scale testing. Nevertheless, I believe the future of user interfaces will be even more personalized and optimized to match user intent.