QORM vs Google A2UI
A2UI defines how an agent describes a UI to a client. QORM is the runtime that renders, signs, delivers, and packages the whole app. Different layers — here is exactly where each one stops.
What A2UI Is — and What It Deliberately Is Not
A2UI is Google's open, agent-to-client UI message format. Instead of emitting HTML or code, an agent streams a flat, adjacency-list component model: each message describes components that reference their children by ID, which makes the format LLM-friendly — a model can generate it incrementally, token by token, and the client can render progressively as messages arrive. It has been adopted by projects like CopilotKit and Flutter's GenUI SDK as the wire format between agents and generative-UI clients.
That design is intentionally narrow — and that is a feature, not a flaw. A2UI does not specify the renderer (each client maps messages to its own widget catalog), the transport, delivery or updates, content signing or integrity, or any form of app packaging. It answers one question well: what does the agent say to the client?
What QORM Is
QORM (Query · Observe · Render · Mutate) is a complete, agent-native app platform in pure Go. An app is language-neutral JSON — qorm.json plus scenes/ and actions/ — and one runtime does the rest: it renders the app live in the browser, snapshots static HTML, ed25519-signs it into a content-addressed bundle, delivers updates over the air with one-command rollback, and packages the same app for web, iOS, Android, desktop, and mini-programs.
Because the runtime itself is the integration point, QORM exposes the running app to AI agents through 20+ MCP tools: inspect the UI tree, query and set state, preview and apply patches with optimistic tokens, and verify rendered geometry with qorm measure and qorm check. Humans and agents share the same live session — SSE keeps every observer in sync, and qorm_activity streams user actions back to the agent.
Side by Side
| Dimension | Google A2UI | QORM |
|---|---|---|
| Scope | Protocol — a UI message format between agent and client | Platform — runtime, delivery, and packaging for complete apps |
| Renderer | Unspecified; each client maps messages to its own widgets | Built-in: one pure-Go runtime renders to HTML/CSS and native shells |
| Delivery / OTA | Out of scope | Content-addressed bundles, over-the-air updates, instant rollback |
| Signing / integrity | Out of scope | Every bundle is ed25519-signed and verified before activation |
| Packaging targets | Out of scope | Web, iOS, Android, desktop, mini-program — from the same JSON app |
| Human-AI shared live session | Not defined by the spec | Yes — SSE sync plus qorm_activity streams user actions to the agent |
| Verification | Not defined by the spec | Agents verify rendered geometry with qorm measure / qorm check |
Which One Do You Need?
If you are building your own generative-UI client and need a clean, streaming, LLM-friendly way for an agent to describe interface trees, A2UI is a well-designed format for exactly that job — and it composes naturally with renderers and frameworks you already have.
If what you need is the app itself — rendered, signed, delivered over the air, packaged for every major platform, and drivable live by both a human and an AI agent in the same session — that is the layer A2UI deliberately leaves open, and the layer QORM fills. The two are not enemies; a QORM runtime could in principle consume an A2UI stream as one more input format.
Also see QORM vs AG-UI (CopilotKit) for the event-transport side of the ecosystem, or return to the ecosystem overview.
Try the Full Platform
QORM is open source under the MIT license. Scaffold an app with one command and drive it from your agent over MCP.
github.com/qorm/qorm