GenUI-Harness Replaces Multi-Turn Agent Clarification With Data-Grounded Generative UI
GenUI-Harness pairs read-only tool exploration with a GUI Coder Agent to replace slow text clarification with structured, data-grounded interfaces. The architecture also uses sandbox execution and meta-reward auditing to verify generated front-end code before action execution.

Plain-text chat breaks down quickly when an operational workflow requires comparing database records and filling structured parameters. Users spend extra turns translating preferences into prose while the agent pieces fragmented replies into tool arguments.
GenUI-Harness addresses that mismatch by placing an ephemeral generative UI between database retrieval and action execution. Instead of negotiating missing details in prose, the harness renders a task-specific interface anchored in verified records. Users then confirm structured inputs directly.
In short
- GenUI-Harness splits interaction into read-only database exploration, dynamic front-end code synthesis by a GUI Coder Agent, and downstream tool execution.
- Anchoring controls in verified database records reduces ambiguity and cuts dialogue rounds in evaluated workflows, even when prompts are already clear.
- Executable interface generation adds verification overhead, requiring Dynamic UX for sandboxed interaction capture and Reward Auditor to curb reward hacking.
Separating Retrieval From Interface Synthesis
Most agent systems ask one conversational loop to query data, resolve missing constraints, and invoke actions. That design pushes cognitive load onto operators who must read scattered options in prose before typing structured selections back.
GenUI-Harness separates those responsibilities across a staged pipeline. During pre-agent exploration, a Tool Agent executes read-only calls to collect relevant database records and candidate options. A GUI Coder Agent then inspects the request alongside those retrieved records, identifies ambiguities, and generates front-end code for a tailored canvas.
This split assigns each job to the component suited for it. Deterministic database queries supply grounded candidate options. The coding agent builds controls only for unresolved fields, while the human operator confirms intent through direct manipulation before downstream execution.
Sandbox Verification and Meta-Reward Auditing
Training a model to emit interactive front-end code introduces failure modes that text-only agents avoid. Full browser execution for verifiable reinforcement learning rewards is expensive, yet relying on LLM-as-a-Judge scoring opens the door to reward hacking.
GenUI-Harness pairs dedicated mechanisms to keep training grounded and affordable. Dynamic UX provides a lightweight package that supports interactive rendering and reward collection inside an isolated sandbox. Reward Auditor acts as a meta-reward layer that tracks reward distributions and distills diagnostic patterns into a shared rubric and scoring specification.
That dual check changes how teams evaluate agent interfaces. Rather than trusting free-form visual scores alone, engineers bind interface rewards to executable state transitions and audited scoring rules.
Operational Gains and Architectural Trade-Offs
Evaluation on UI-Tau Bench adapts Tau-Bench tool-use workflows across domain databases and shows higher task completion than text-only and smolagents baselines. Smaller backbone models trained inside GenUI-Harness also outperformed larger frontier baselines while reducing average dialogue rounds.
Those improvements held on both underspecified requests and clear prompts, showing that structured canvases help even when requirements are already explicit. For operations leaders, fewer clarification turns mean less manual handoff friction and lower grounding error risk before write actions execute.
The trade-off is a heavier runtime and governance surface than plain chat. Supporting ephemeral UI synthesis forces teams to maintain sandboxed rendering, front-end validation, and reward auditing alongside existing tool permissions.
Generating live front-end code per request pays off when multi-field database choices bottleneck the workflow enough to justify sandboxed UI verification.






