Should you build your product's generated UI in-house? We measured the choice instead of arguing about it. Genbench puts seven contenders through 196 cases across fourteen fictional products, with the same data, tools and design brief. Vendo reached 100% data integrity, produced 99% working screens, tied the best requirements score, and had the lowest cost per working screen.
| Measure | Vendoscreen agent | Thesys C1generative UI | GPT-5.6 Terrasingle model call | Claude Sonnet 5single model call | Gemini 3.1 ProPreviewsingle model call | Codex CLIGPT-5.6 Terracoding agent | Claude CodeClaude Sonnet 5coding agent |
|---|---|---|---|---|---|---|---|
| Working screensPassed the deterministic floor | 99% | 53% | 73% | 58% | 56% | 67% | 53% |
| Data integrityVerified against tool data | 100% | 92% | 96% | 96% | 96% | 97% | 98% |
| Requirements metBlind rubric judge | 92% | 78% | 90% | 90% | 82% | 89% | 92% |
| Cost per working screenGeneration spend only | $0.06 | $0.16 | $0.07 | $0.14 | $0.28 | $0.19 | $0.42 |
| Average timeWall clock to settled screen | 30s | 22s | 32s | 54s | 76s | 35s | 90s |
- Working screens passed the benchmark's delivery, render, validity and interaction checks.
- Data integrity means every numerical claim could be traced to tool data or reproduced by an executed derivation.
- Requirements met is the share of requested rubric lines the screen satisfied.
- Cost per working screen divides generation spend by the screens that passed the working-screen check. Benchmark grading is separate.
- Average time is wall-clock generation time to a settled screen.
The one-call builds
The simplest in-house path gives a frontier model the product context, tools and task, then asks for the screen in one call. It is fast, cheap and surprisingly capable. GPT-5.6 Terra was the strongest of the single-call builds here: 73% working screens, 90% of requirements met, 32 seconds on average and $0.07 per working screen.
The problem is that its failures can look good. A polished interface can omit part of the ask, wire a control to nothing or print an unsupported total. The benchmark catches those gaps afterward, but the artifact carries no proof. If you take this route, verification is still yours to build.
Three models, one appealing starting point and the same unresolved question: how do you know the screen is telling the truth?
The agent CLIs
A coding agent can inspect what it made, revise it and try again. That extra loop bought quality. Claude Code tied Vendo for the best requirements score at 92%. Codex reached 89%. The extra loop also showed up in the clock and bill. Claude Code averaged 90 seconds and $0.42 per working screen. Codex averaged 35 seconds and $0.19.
More reasoning is not the same as proof. Claude Code reached 98% data integrity and Codex reached 97%, compared with 100% for Vendo. Where an agent missed, a value could look plausible without tracing back to the supplied data. An agent can notice and repair a mistake, but it has no mechanical obligation to prove every number it prints. If an agent CLI becomes your production path, that verification layer still belongs to you.
Iteration improves the screen. It does not, by itself, establish where the screen's numbers came from.
The closest product
Thesys C1 is the closest like-for-like product. Its generative UI API and React renderer turn a response into a working interface. We followed its documented integration path, then gave it the same data, tools and design brief as every other contender.
Its clearest result was speed: 22 seconds per screen, at $0.16 per working screen. If time is your binding constraint, Thesys deserves a serious look. The tradeoff was 53% working screens, 78% of requirements met and 92% data integrity.
Vendo
Vendo's result starts with the row we care about most: 100% data integrity. Every numerical claim on its scored screens was traced to the supplied tool data or cleared by an executed derivation. Nothing passed because a reviewer thought it looked right.
It also produced 99% working screens and met 92% of requirements, tied with Claude Code for the best requirements score. It cost $0.06 per working screen, the lowest in the table, and averaged 30 seconds. It was as correct as the best agent, at a fraction of the time and cost, with every number verified.
Vendo's screen for the same benchmark case shown above.
That result comes from a different architecture. Vendo does not ask a model for a finished file and trust what comes back. A dedicated screen agent works inside the product runtime. It reads the product's design rules, theme, component catalog and real tool shapes. The screen it creates calls the same host tools as the rest of the product, through the signed-in user's authority, approvals and audit trail. It never needs to edit the host codebase.
Every save is treated as a draft that must earn its way onto the screen. Vendo parses it, compiles it, type-checks it, verifies its tool queries, runs those queries against real responses, renders the result and validates the final component tree. A broken save does not paint. The agent gets the exact refusal and the data each query returned, fixes the problem and saves again. Before the turn ends, the stored screen goes through a final review, and any findings go back for a focused repair.
This is how Vendo turns model output into a product artifact before genbench ever sees it. Genbench then independently checks the rendered result, including whether every displayed number can be derived from the supplied data.
That matters beyond this benchmark. Most product teams cannot put every customer's bespoke view or workflow on the roadmap. With Vendo, a customer can ask for one and get a brand-native surface built on their permissions and live product data, without an agent editing the host codebase. The long tail of customer requests stops being a queue of one-off engineering projects. For a buyer, Vendo also replaces much of the agent loop, renderer, tool wiring, safety policy and validation system that every in-house path leaves you to build.
Three products, three different screens. The model generates each screen. The runtime makes it part of the product.
How we kept it fair
Every contender received the same product data, tool schemas, tool responses and design brief. The page-writing baselines also received one shared harness contract covering the viewport, actions and settle signal. Vendo deliberately did not receive that contract because its own runtime already owns those seams, so we do not claim that all seven saw an identical prompt.
For the baselines, a test compares the shared blocks each harness actually sent, byte for byte, and rejects extra coaching about the recorder, network, confirmations or viewport. After generation, every page received the same font and recorder, then faced the same screenshot, click probe and floor. Each contender kept a budget suited to its execution model.
The judge saw no contender name, model or run path, and rubric lines were shuffled in a stable order. Every screen, verdict, tool call, timing and dollar is preserved in the public artifacts. You can inspect the evidence behind any cell.
How data integrity is verified
Data integrity does not come from visual review. A polished screen can still print a value that the underlying data does not support, so genbench checks every numerical claim against the recorded tool responses.
Genbench checks every numerical claim in three stages. First, an exact string from a tool response clears without a model. Next, a pinned triage model may waive tokens that are not claims, such as a step number or duration. It cannot approve a claim. Everything left goes to an auditor that may return only JavaScript over the tool data. The harness runs that code in a sandbox and compares its result with the screen. A counterfactual run rejects programs that merely hard-code the answer.
The model may propose a derivation, but it never awards the pass. Only executed
code does. The full program, return value, verdict and attempt count remain in
result.json for anyone to inspect.
What this does not measure
This is a corpus of 196 authored cases across fourteen fictional products, not production traffic. It tests one bounded request and known tool data at a time. It does not measure months of user behavior, changing requirements or whether a design matches your customers' taste.
Correctness and design still come from a pinned model judge. It is blind and versioned, but it remains a model. The honest-data check is mechanical at the point of conviction, but it excludes dates and chart-axis numbers. Screens with nothing to examine are reported as vacuous, not clean. The action probe reloads the page for each control and follows a flow only one step past confirmation. Finally, models, APIs and prices change. These results describe the recorded versions and price table, not a permanent ranking.
Run it yourself
The benchmark is in the public Vendo repository. Each world is plain JSON: a product identity, theme, style rubric, tools and test cases. You can inspect every artifact and rerun the matrix on your own keys.
You can also add your product. Describe its design and tools, write the requests your customers make, then score every contender against evidence you care about. If the result does not survive your world, it should not decide what you build or buy.
If you would rather start with Vendo, the docs are here.