GenUI Portal by Very Good Ventures

GenUI Portal by Very Good Ventures

Make generative UI pay.

Every generated screen costs money. GenUI Portal serves generative UI into your app and tests it against the UI you ship today, so you know whether it benefits your customers and business.

Talk to us See how it works
In your app · generated UI

I need shoes for a wet trail race next month.

  • Ridgeline GTX trail runner

    $149

  • Mudguard waterproof gaiter

    $34

  • Wet-grip race sock, 2 pack

    $22

In GenUI Portal · pilot results

Revenue per session
$2.64
vs. $2.13 baseline
Token cost per session
−$0.03
Net lift vs. baseline
+$0.48
Illustrative numbers from an A/B test against the baseline, your current UI.

Why GenUI Portal exists

Every GenUI experience has to prove it pays.

Generative UI can tailor every screen to the person looking at it. It also sends a model call with every turn, and those calls add up. Product teams need more than a good demo to keep it. They need proof that it moves a number the business cares about, and that the lift is bigger than the bill.

Measure the impact of GenUI

Know whether GenUI benefits your customers and business.

LLM costs are real. GenUI Portal runs your generated experience against your existing UI and counts the goal you care about for each arm. It puts a dollar value on every conversion and subtracts what the tokens cost. The result is a return figure you can take into a budget meeting.
  • A/B tests against the UI you ship today, on real traffic
  • Goals with a dollar value, such as a purchase or a sign-up
  • Return reported net of token cost

Pilot results · illustrative

Baseline, your current UI$2.13 per session
GenUI$2.64 per session
Token cost
$0.03
Net lift per session
+$0.48
Sessions per arm
18,240

Works on any platform

Works on any platform.

Generated UI renders with your own components, so it looks like your product and follows your design system. The Flutter SDK covers iOS, Android, and web from one codebase. The web SDK brings the same model to React and framework-free JavaScript, and native SDKs do the same for Swift and Kotlin apps. Every SDK speaks the same protocol, so one project serves every platform you ship.
  • Flutter SDK for iOS, Android, and web from one codebase
  • Web SDK for React and plain JavaScript
  • Native iOS and Android SDKs for Swift and Kotlin apps
  • Backend SDKs that mint session tokens on your server

Works with any model or vendor

Use the model that fits, and switch when a better one ships.

GenUI Portal is not tied to one model vendor. Point a project at Gemini, GPT, Claude, or an open-weight model you host yourself. A model is part of a project version, so trying a new one is a draft you can preview and test against the one serving today, with cost and speed measured on every turn.
  • Gemini, GPT, and Claude with your own API key
  • Open-weight models hosted where you choose
  • Generation options tuned per model
  • Switch models in a new version, then A/B test the change

Models on this project · illustrative

  • Gemini $0.0034 per turn · 1.1 s Published v3
  • Claude $0.0041 per turn · 1.3 s Testing in v4
  • GPT $0.0038 per turn · 1.2 s
  • Open-weight, self-hosted $0.0012 per turn · 1.6 s

Control costs

See what every turn costs, then spend less on the next one.

Every turn records its input and output tokens and what they cost, so you can see where the money goes. Most of a turn's input is your own configuration, so the numbers tell you what to trim. A shorter system prompt, a leaner catalog, or fewer tools on offer each show up on the next turn's bill. We also implement techniques to drive down token usage. Your app gets those savings without any changes.
  • Input tokens, output tokens, and dollar cost on every turn
  • Totals per conversation and per project
  • Token-saving techniques applied for you

Recent turns · illustrative

  • “Shoes for a wet trail race”1,610 in · 230 out · $0.0041
  • “Show me something lighter”1,050 in · 162 out · $0.0027
  • “Compare the top two”1,288 in · 218 out · $0.0034
  • Catalog trimmed to 12 items−22% input tokens

Efficient workflow

Change the model, the prompt, the catalog, or the tools. Preview it in your app.

Product teams iterate on GenUI the way they iterate on everything else. Swap the model, tune the system prompt, add a component to the catalog, or wire up a new tool from the dashboard. Every change lands in a draft version of the project. You preview that draft in your own app, then publish when it is ready.
  • Swap models and tune generation options
  • Version the system prompt, catalog, and tools together
  • Preview a draft inside your own app before customers see it
  • Publish when it is ready, and roll back if it is not

Project versions

  1. New system prompt and a Comparison componentDraft v4
  2. Previewing on your phone, in your appPreview
  3. Serving customers todayPublished v3

Measure the impact of those changes

Every change is an experiment.

A smarter prompt that doubles the token bill may not be smarter. Run a new version against the one serving today as an A/B test, and see whether the change moved return up or down once its token cost is counted. Keep the versions that pay and roll back the rest.
  • A/B test a new version against the one serving today
  • Both arms measured on the same goal and the same cost basis

A/B test · illustrative

A v1

Serving today

Net lift per session
+$0.31

B v2

New layout

Net lift per session
+$0.48

+55% uplift. v2 earns more per session after token cost.

18,240 sessions per arm, same goal, same cost basis.

Guardrails

Generated UI that stays inside the lines.

LLMs hallucinate. GenUI apps can't allow that. GenUI Portal provides guardrails that check every response before your app sees it. Schema validation makes sure the model only uses components from your catalog, with properties they accept. ID checking confirms that every product or other entity the model refers to exists in your systems, so a customer never sees an item the model made up.
  • Schema validation against your catalog on every response
  • ID checking for products and other entities before they render

Checks on one response

  • Schema validProductCard and Comparison are in your catalog
  • IDs resolveAll 3 products exist in your product service
  • Blocked before renderA made-up product id never reaches the screen

Safe

Protection against prompt injection and data leaks.

GenUI Portal plugs into dedicated protection such as Model Armor. It screens what customers type and what the model sends back for prompt injection and sensitive data. A turn that fails is stopped on the server, and your app gets a clear signal instead of an unsafe screen.
  • Model Armor screening on what customers send and what the model returns
  • Unsafe turns stopped on the server before anything renders

Screening on every turn

  1. Customer message screenedInbound
  2. Model and tools runTurn
  3. Response screenedOutbound
  4. Safe UI renderedDelivered

Save your customers time

Find the slow step and make it faster.

Every request is traced from the moment it arrives to the moment your app can render it. Open any turn and see how long each step took, from safety screening to the model to every tool call and validation. When a response feels slow, you know where the time went.
  • A trace of every request, step by step
  • Time spent in the model, each tool, and each check
  • Logs you can search by conversation

One turn, step by step · illustrative

Screen input
84 ms
Model
1.2 s
searchProducts
540 ms
Validate
31 ms
Screen output
92 ms

For engineers

Your components, our serving path.

The model never draws pixels. It picks from a catalog of your own components and emits A2UI, an open protocol for generated UI. The platform validates every message against your catalog, and your app renders it with the widgets you already ship. Your design system and your accessibility work stay in your codebase.

  1. Your app sends a turn
  2. Safety screening
  3. Model and your tools
  4. Schema and ID checks
  5. Your widgets render it
// A conversation against a published project version.
final conversation = GenUiPortalConversation(
  config: const GenUiPortalConfig(organizationId: 'org_acme'),
  projectId: 'prj_storefront',
  version: '3',
  catalog: GenUiPortalCatalog(items: [
    ...genUiPortalBuiltInLayouts(),
    const ProductCard(), // your widget
  ]),
  sessionToken: backend.mintSessionToken,
);

// Render whatever the model generates.
GenUiPortalConversationBuilder(
  conversation: conversation,
  builder: (context, surfaces) => Column(children: [
    for (final surface in surfaces)
      GenUiPortalSurfaceBuilder(surface: surface),
  ]),
);
The Flutter SDK. One codebase covers iOS, Android, and web.

  • Versioned projects

    Model, system prompt, catalog, and tools are pinned to a project version. Your app asks for a version, so a publish never changes a screen you did not mean to change.

  • Session tokens from your backend

    Backend SDKs mint short-lived session tokens on your server, so no secret key ever ships in your app.

  • An MCP server for coding agents

    Agents can draft catalog items and project versions through the same public API the dashboard uses. Publishing stays with a person.

  • Observable from day one

    The API emits OpenTelemetry traces and metrics, and every response carries a trace id that finds its request in your logs.

Built by Very Good Ventures

Made by a team that ships Flutter apps every day.

Very Good Ventures helps companies design and build digital products in Dart and Flutter. GenUI Portal comes out of that work, and we hold it to the same bar we hold client code to. It is built for a team to live with for years.

Learn more about Very Good Ventures

Talk to us

Tell us what you would use first.

We are building GenUI Portal with the teams who will use it. Tick the parts that matter to you and send us a note. We will set up a conversation about your product and your goals.

Nothing ticked yet. Use “I'm interested in this” on any section above.

    Talk to us

    Or write to genui@verygood.ventures