What Is Client-Approved UI?
Client-approved UI is a generative interface model where an app only renders layouts built from a pre-approved whitelist of components, styles, and actions…

Client-approved UI is a generative interface model where an app only renders layouts built from a pre-approved whitelist of components, styles, and actions, even when those layouts are proposed by an AI system. The client acts as a strict renderer of a validated schema: every screen must conform to that schema before it appears, ensuring that AI-driven interfaces remain native, safe, and on-brand.
How Client-Approved UI Works
In a client-approved UI model, the core idea is that the client never executes arbitrary UI instructions. Instead, it only renders structures that match a constrained schema of allowed SwiftUI views, styling tokens, and interaction patterns.
You can think of it as a contract between three parties:
- The AI layer, which proposes UI layouts and flows.
- The validation layer, which enforces the whitelist and rejects anything unsafe or off-brand.
- The iOS client, which renders only validated, schema-compliant SwiftUI screens.
For Uzori-style generative UI, the flow typically looks like this:
- User request: A user asks the assistant to perform a task, like “help me configure roaming protection” or “show me gowns under $300 with long sleeves.”
- AI composition: An AI agent decides what type of screen makes sense (wizard, comparison view, product explorer) and constructs a candidate layout using declarative components: lists, forms, carousels, detail cards, etc.
- Server-side validation: Uzori’s validation layer inspects the candidate layout against a component whitelist SwiftUI schema and a set of style and action rules.
- Only pre-approved SwiftUI components are allowed.
- Styles must match the brand’s design system.
- Actions must map to safe, known backend endpoints.
- Streaming to the client: If the layout passes validation, the server streams a schema-compliant description of the screen to the iOS app.
- Native rendering: The app’s Uzori SDK UI framework turns that description into real SwiftUI views, updating the interface in place.
Because SwiftUI is declarative and data-driven, this pipeline fits naturally. Apple explicitly highlights that SwiftUI views are derived from model data and update automatically when state changes, which makes it straightforward to treat validated UI descriptions as just another state source. The client never runs remote code; it only renders server-validated SwiftUI components.
Why Client-Approved UI Matters for iOS Teams
Client-approved UI matters because it balances generative power with architectural safety. For iOS engineers who care about UX polish, performance, and maintainability, it provides a way to adopt AI without giving up control.
Several pressures converge here:
- AI UX is moving beyond chat boxes. Teams want AI to orchestrate flows, comparison views, and dynamic user interfaces—not just send paragraphs of text.
- SwiftUI is now the default for new Apple platforms. Apple calls SwiftUI the best choice for new apps, the preferred choice for visionOS, and mandatory for watchOS. Any AI-native iOS solution that ignores SwiftUI is fighting the platform.
- Mobile UX quality depends on consistent patterns. Baymard’s 1,000+ hours of native mobile UX research and 360+ guidelines show that layout discipline, interaction patterns, and information architecture are key to usability—not free-form improvisation.
- Security guidance favors constraints and verification. OWASP MASVS emphasizes standardized verification for app controls; a validation layer that checks generated UI against an allowlist reflects that mindset.
Client-approved UI gives you:
- Brand safety: Prevent off-brand SwiftUI screens by enforcing your design tokens, typography scale, spacing system, and component library.
- Interaction safety: Restrict actions to known, vetted operations on your backend (e.g., OpenAPI-described endpoints), avoiding unexpected network calls or data exfiltration.
- Performance and accessibility: Because everything is native SwiftUI, you inherit Apple’s accessibility fundamentals and performance optimizations instead of relying on web overlays.
- Experimentation without chaos: Product teams can iterate on AI-led flows—infinite wizards, explorers, and concierges—without proliferating bespoke client code or risking broken navigation.
With Uzori specifically, the validation layer is the trust boundary. Uzori’s server-driven UI iOS framework ensures that every AI-proposed screen is checked before it hits the device, aligning with the principle that generative UI must operate inside a strong, typed contract.
For a deeper architectural walkthrough of how this fits into server-driven UI on iOS, see our guide: Server-driven UI on iOS: turn AI answers into native SwiftUI in real time.
Related Terms and How Client-Approved UI Differs
Client-approved UI often gets confused with several adjacent concepts. They share some DNA, but the trust model is different.
Server-Driven UI
Server-driven UI describes any pattern where the server controls composition and the client renders native components from a schema. Uniform’s SwiftUI examples show the server choosing which components to show, while the iOS app acts as a renderer.
Client-approved UI is a specific, constrained variant of server-driven UI:
- It assumes generative composition (typically via LLMs) rather than human-authored layouts.
- It adds a formal validation layer that treats server output as untrusted until proven schema-compliant.
- It emphasizes a component and style whitelist, not just a flexible layout language.
In short, all client-approved UI is server-driven UI, but not all server-driven UI is client-approved. The difference is the level of automation and the rigor of validation.
Generative UI / OpenUI
Generative UI, including OpenUI-style approaches, focuses on turning LLM responses into interactive cards, dashboards, and flows. The goal is to move beyond plain text answers.
Client-approved UI overlaps with generative UI but tightens the loop:
- Generative UI: “AI can invent any interface it wants; the renderer does its best.”
- Client-approved UI: “AI can propose interfaces, but only those that match our approved schema, styles, and actions are allowed to render.”
Uzori’s model is explicitly client-approved generative UI. The AI composes layouts; the Uzori validation layer enforces the whitelist; the SwiftUI client renders only approved screens.
Plain Chat-Based AI Interfaces
Traditional chat UIs simply show text responses. If the AI suggests “tap here, then go there,” users have to manually translate that into actions across different parts of the app.
Client-approved UI is different in kind:
- The AI answer is the interface.
- Instead of saying “add these three products to your cart,” the assistant streams a native SwiftUI screen with product cards, filters, and an Add to Cart action.
- All of that is constrained by the component whitelist and validation layer.
Remote Code Execution or Scripting
Some experimental systems push down code or scripts that the client executes to render dynamic UI. That approach can be powerful but raises significant security and stability concerns.
Client-approved UI explicitly avoids remote code execution:
- The client renders structured data, not executable instructions.
- Allowed components and modifiers are known at compile time.
- OWASP-style verification can focus on a finite set of controls and actions.
Example: Preventing Off-Brand SwiftUI Screens with Uzori
Consider an iOS product team at a Series B startup building an AI concierge into their shopping app. They want users to describe what they’re looking for in natural language and get a tailored, interactive experience.
Without client-approved UI, several failure modes appear:
- The AI might output a cluttered grid with inconsistent spacing and typography.
- It could invent a “Buy Now” button that bypasses required consent steps.
- It might surface fields that request sensitive data in ways that violate internal policy.
With a client-approved UI model backed by Uzori’s validation layer SwiftUI integrations, the flow changes:
- The AI decides a product explorer layout is appropriate: a filter bar, a set of product cards, and a comparison tray.
- It composes that layout using only known component names (e.g.,
ProductCard,FilterChip,PrimaryButton) and style tokens from the brand. - The Uzori validation layer checks:
- Every component appears in the server-validated SwiftUI components whitelist.
- Styles match the predefined design system (no rogue font sizes or corner radii).
- Actions correspond to allowed backend operations (e.g.,
addToWishlist,startCheckoutWithConsent).
- Any violation—like an unknown
InstantBuyButton—is rejected or rewritten before streaming. - The iOS app receives a clean, validated schema and renders it with SwiftUI.
From the engineer’s perspective, this has several benefits:
- They integrate one SwiftUI screen via the Uzori SDK UI framework.
- They maintain architectural integrity: navigation, state management, and accessibility stay within their existing patterns.
- They can let AI orchestrate rich, task-specific flows while staying confident that no unsafe or off-brand screens will slip through.
This is the essence of client-approved UI in Uzori’s world: the interface builds itself, but only inside the boundaries you define. For teams ready to try this pattern in production, Uzori’s platform at uzori.ai offers a practical way to generate native iOS UI from LLM responses without compromising safety or brand.