QORM vs AG-UI & CopilotKit
AG-UI standardizes the event stream between an agent and a frontend. QORM removes the gap entirely: the runtime is the app, and agents mutate it live over MCP while humans watch the same session.
What AG-UI and CopilotKit Are
AG-UI is an open agent-to-frontend event and transport protocol from the CopilotKit project. It defines a typed event stream — messages, tool calls, state deltas, lifecycle events — that carries an agent's activity into a user interface, so frontends can render agent progress, shared state, and generative UI without bespoke WebSocket plumbing. It is deliberately transport-agnostic and composable: content formats like A2UI or MCP Apps can ride on top of it as the "what," while AG-UI remains the "how it flows."
CopilotKit is the React framework built around AG-UI: hooks and components that let a React app subscribe to that event stream and turn it into copilot chat, shared state, and agent-rendered components. It is a solid choice when your app is already a React codebase and you want to graft agent interactivity onto it.
What QORM Is
QORM (Query · Observe · Render · Mutate) starts from the opposite direction: it is a complete, agent-native app platform in pure Go. The app is language-neutral JSON — qorm.json plus scenes/ and actions/ — and the runtime renders it live, signs it into a content-addressed ed25519 bundle, delivers updates over the air with rollback, and packages it for web, iOS, Android, desktop, and mini-programs.
There is no event-protocol bridge to build because there is no gap to bridge. The agent talks to the running app directly through 20+ MCP tools: inspect the UI tree, query and set state, dispatch actions, preview and apply patches atomically, and verify rendered geometry with qorm measure and qorm check. The human is in the same session — SSE syncs every observer in real time, and qorm_activity streams the user's actions back to the agent, so both parties always see the same live app.
Side by Side
| Dimension | AG-UI / CopilotKit | QORM |
|---|---|---|
| Scope | Protocol — a typed agent-to-frontend event stream, plus a React framework around it | Platform — runtime, delivery, and packaging for complete apps |
| Renderer | Your React app renders what the events describe | Built-in: one pure-Go runtime renders to HTML/CSS and native shells |
| Delivery / OTA | Out of scope — deploy your frontend as usual | 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 | Wherever React runs; native packaging is up to you | Web, iOS, Android, desktop, mini-program — from the same JSON app |
| Human-AI shared live session | Agent state syncs to the UI; the model is event-driven, frontend-mediated | Yes — agent and human share one live runtime; qorm_activity streams user actions to the agent |
| Verification | Not defined — the agent cannot measure what the user sees | Agents verify rendered geometry with qorm measure / qorm check |
Which One Do You Need?
If you have an existing React application and want to wire an agent's state, messages, and tool calls into it, AG-UI gives you a clean standard for the transport and CopilotKit gives you the components — you keep full control of the frontend, and you also own its rendering, deployment, and distribution story.
If you need the whole loop — an app the agent can inspect, mutate, and verify directly, in the same live session the human is using, then signed, delivered over the air, and packaged across platforms — that is an agentic UI platform, and it is what QORM is built for. The two layers compose: an AG-UI-style event stream could drive a QORM runtime just as it drives a React one.
Also see QORM vs Google A2UI for the UI-message-format 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