Skip to content
Public preview · the console is open

Is your agent still talking to your customers in a text wall?

Book a demoStart free in the console ↗

The same agent, two worlds: the wall on the left, the interface on the right. Click the right side, and watch what the left has to do to keep up.

Invoicing · yourssimulated replaydecision card
The text wall · your agent today

Your agent, text only

with generative UI, powered by

Your agent, with generative UI

returned to your agentclick any control ↑

Tap a control and watch the wall keep up.

Six hand-built scenes. A simulated replay: the real generation runs in your agent. Ship it yourself from the console ↗

Book a demo and we’ll mirror your product’s own tools, live.

What’s GGUI?

GGUI is an open protocol for generative UI. The name abbreviates generative graphical user interface, and it’s open source. We also serve it as Generative UI as a Service, so you can adopt it without running anything yourself. Or self-host it; the contract is identical.

Go to the cloud console ↗Go to GitHub ↗

Why generative UI? Every interface is an experiment.

variants served per render, with no redeploys and no frontend sprint
Booking flow · simulated experimentarm A · slot grid
Find me a morning slot next week.

Studio session · mornings

pick a time

Tue 09:00Tue 10:30Wed 08:30Wed 11:00Fri 09:30Fri 10:00

Conversion, by iteration

arm A0%

The agent serves a different generated interface to each cohort. The numbers here are illustrative; the mechanism is the point. Iterate without shipping code, keep the winner.

Generative UI as a service.

Adopting it is one config block, not a migration. Point your agent at the hosted endpoint and every tool call can put a real interface in front of your users.

The whole integration

{
  "mcpServers": {
    "ggui": {
      "type": "http",
      "url": "https://mcp.ggui.ai",
      "headers": { "Authorization": "Bearer ggui_user_…" }
    }
  }
}

No frontend code

Your agent describes the interface in natural language. GGUI generates it, renders it, and returns what the user did as structured data. The interface then moves to its next state, like you just saw.

Just an MCP server

That config is the whole thing. Any client that supports MCP Apps gets this generative UI right away, claude.ai and your own SDK loop included. No SDK to adopt, no runtime to embed.

building an agent too? meet Guuey →

01 / How it works

Four things happen between “agent wants to show” and “user sees a UI.”

Most MCP tools ship without a UI: agents can call them, users see text. And one UI per tool doesn't compose; a calendar screen doesn't help when the agent also needs weather and email on the same surface. The way out is a protocol that picks or generates the right interface against a shared data contract. Here is the round-trip.

01

The agent calls GGUI over MCP.

Your agent doesn’t need to know about UI. It calls a tool. GGUI is that tool, exposed as an MCP server, and any agent that speaks MCP can call it.
02

The user sees something right away.

Before GGUI has decided what to render, a preview skeleton streams onto the user’s surface: a small subset of primitives designed for fast, partial-render feedback. No spinner, no blank state. The wait becomes assembly.
03

GGUI picks or generates a blueprint.

Meanwhile, GGUI checks the registry: blueprints the developer wrote, and blueprints the agent generated on earlier requests. If one fits the data the agent is passing, it’s reused directly. No fresh generation, the same proven screen every time. If none fit, GGUI generates a new one against the same data contract, and keeps it for next time.
04

The final UI replaces the skeleton. Events flow back.

When the blueprint is ready, it takes over the user’s surface: web, mobile, or spatial. When the user interacts, events return to the agent along the same data contract that drew the UI. No glue code in between.
UserAgentGGUIasks for somethingMCP callgenerative UIrenders UI

The full spec (wire protocol, blueprint schema, data contract rules) lives in the docs.

Read the spec ↗Star on GitHub ↗
02 / The gap

Generative UI alone isn’t enough. MCP Apps alone isn’t either.

Each half solves some of the problem. Neither alone makes agent-rendered interfaces production-grade. GGUI closes the gap with a typed data contract. Hand-built Apps paint faster, when someone has built one. GGUI trades that first-paint edge for coverage: every tool gets a UI, contract-checked, hand-built or not.

Generative UI alone
MCP Apps alone
GGUI
Speed
LLM call per render, in seconds.
Pre-shipped HTML: instant.
Reuses proven screens with zero regeneration; renders in seconds.
Truth
Buttons can do anything.
Hand-validated by the host.
Contract validated both ways.
Coverage
Any MCP, but unreliably.
Only servers that shipped an App.
Any MCP, reliably.
Composition
Per-tool, no sharing.
Sandboxed, no cross-server.
Cross-MCP in one session.
03 / Why GGUI

What this gives you that a UI kit can’t.

01

Generated UI, bounded by a contract.

Every surface the agent renders is validated against a declared data contract, both ways. Outbound emissions are schema-checked before fan-out; inbound user actions are allowlisted on ingress. The harness can invent anything, but the contract layer keeps it inside spec. We wrote the argument up: The contract is the product ↗
02

The server owns the session, not the client.

A neutral session authority (not the agent, not the browser) holds the running contract. Sessions survive reconnects via ring-buffer replay. Multiple subscribers can watch one session at once: two users, or a user plus a dashboard, or a mobile client plus a desktop one.
03

The UI layer doesn't care which framework you run.

Add GGUI to an existing Claude, OpenAI, or Google agent, or any MCP-speaking runtime like LangGraph, with one HTTP entry in your MCP config. Keep your chat runtime. The GGUI layer is additive. It ships the interface, nothing else.
04 / Measured in public

Benchmarked in the open. Built to be believed.

Generation quality, latency, and cost, measured across providers on an open-source runner and published with receipts.

01

Every number carries its receipt.

Each published figure names its run id, commit, model, date, and sample size. If you can’t trace a number to the run that produced it, it doesn’t go on the dashboard.
02

Regressions publish as honestly as wins.

When a change makes generation worse, the dashboard says so. Outages are annotated, never deleted. A benchmark surface that only ever improves is an ad, not a measurement.
03

The methodology is dated, disclosed, and open.

Scoring runs on a multi-provider judge panel at temperature zero, coverage is disclosed per run, and methodology changes land in a dated on-page changelog. The runner itself is open source. Rerun it and check us.
See the live dashboard ↗Runner source ↗
05 / Origins

Where this comes from.

“I spent years at the Ethereum Foundation as a cypherpunk, building trustless protocols with cryptography. Working with AI agents, I kept seeing the same missing piece: a data contract between the agent and the person it serves. GGUI is that contract.”

— Wanseob Lim, Author of the GGUI protocol
@wanseob ↗
06 / Open protocol & open source

Open protocol & open source.

The protocol and runtime are Apache 2.0. Everything the page claims has a public receipt:

  • npm
    npmjs.com/org/ggui-ai ↗

    @ggui-ai/cli (ggui serve runs the self-hosted MCP server), @ggui-ai/mcp-apps-react and @ggui-ai/mcp-apps-react-native (web and mobile renderers, same contract), and the protocol SDKs · v0.18.0

  • Source
    github.com/ggui-ai/ggui ↗

    The runtime, the samples, and the issues that shape it

  • Benchmarks
    benchmarks.ggui.ai ↗

    Generation quality, latency, and cost, published with regressions included

  • Protocol
    the GGUI protocol spec ↗

    Wire messages, blueprint schema, and the data-contract rules

Apache 2.0 · Built in the open by people who think the interface belongs in the protocol, not the app. It’s early on purpose, early enough that your issues and PRs still shape it. Contributions welcome via github.com/ggui-ai/ggui.

One open protocol. Any MCP. Any agent. Any model.

If you want this to exist, say so where it counts.

Star on GitHub ↗Join the discussion ↗

Don’t want to run it? hosted GGUI starts you with $5 of welcome credit, no card, then bills per render; see the mirror above ↑

07 / Run it your way

Run it your way. Pick a door.

Hosted for zero ops, or self-hosted on your own infra. Bolt it onto an existing agent, start from a sample, or build it into your product as an enterprise. Same wire, same contract, every way.

Hosted

Let GGUI host it.

No server to run. Sign in to the GGUI console, mint a connector key, and point your agent at the hosted endpoint with the one config block shown under Generative UI as a service. Same MCP wire, zero ops. Self-host any time; the contract is identical. Start with $5 of welcome credit. No card. Then pay as you go: 15¢ per render, 2¢ per cache hit. Full pricing. Sign-in privacy is covered in our Privacy Policy. Setup details live in the hosted quickstart ↗.
Open the GGUI console ↗
Existing agent

Point an existing agent at GGUI.

Two steps: run a GGUI server, then point your agent’s MCP config at it over HTTP. Your agent starts rendering generative UIs for every tool it can call. No frontend code, and your framework stays yours.
# 1 · start a ggui server (local dev, skips pairing)
npx -y @ggui-ai/cli serve --dev-allow-all

# 2 · point your agent's MCP config at it
{
  "mcpServers": {
    "ggui": { "type": "http", "url": "http://127.0.0.1:6781/mcp" }
  }
}
See MCP setup ↗
New agent

Start from a first-party sample.

Clone the repo and build on the samples: agent backend, GGUI MCP server, and web client, wired together. Pick your framework: Claude, OpenAI, or Google ADK.
$ git clone https://github.com/ggui-ai/ggui
# agent samples: samples/agents/
#   claude-agent-sdk · openai-agents-sdk · google-adk · with-guuey
# web client: samples/apps/ggui-basic-web
#   (Vite + React + @ggui-ai/mcp-apps-react)

→ follow the samples quickstart in the README
  pnpm dev   # everything → http://localhost:6890
Claude
OpenAI
Gemini
+ any MCP-speaking runtime
Browse the samples ↗
Enterprise

Build GGUI into your product.

The protocol is open and the runtime is Apache 2.0. Embed generative UI in your own service, self-hosted or hosted. First-class integration in your product, a listed framework partnership, enterprise hosted terms, or design partnership: it’s early enough that your use case can still bend the spec. Talk to a human:
Email enterprise@ggui.ai

Bring your product and we’ll mirror it live.

Book a demoor ship it yourself →
The demos above are simulated. This link is not. Try it live ↗
Book a demo

Fifteen minutes, your use case.

We’ll walk GGUI through your product’s tools, live. Leave your email and the scheduling link comes to you.

We send one mail with the scheduling link. No list, no follow-up drip.

08 / FAQ

Common questions. Direct answers.

What is GGUI?
GGUI is an open-source interface layer that lets AI agents show real user interfaces instead of plain text. It runs as an MCP server: the agent describes what it needs to show, and GGUI matches a cached blueprint or generates a UI against the agent’s declared data contract, then renders it on the user’s screen, web or mobile. Interaction events flow back to the agent over the same contract, and the developer writes no frontend code. It runs hosted as generative UI as a service at ggui.ai, or self-hosted from the Apache 2.0 open source.
How do agents use GGUI?
An agent uses GGUI through its MCP config alone. Start the self-hosted server with npx -y @ggui-ai/cli serve, add one HTTP MCP entry pointing at it, and the agent can call GGUI’s tools to put a UI in front of the user for anything it can do. No SDK imports, no event handlers, no frontend code.
Is GGUI open source?
Yes. GGUI is Apache 2.0-licensed and developed in the open at github.com/ggui-ai/ggui. The protocol spec and reference implementations are open, and the @ggui-ai/cli, @ggui-ai/mcp-apps-react, and @ggui-ai/mcp-apps-react-native packages ship on npm.
How does GGUI relate to MCP?
GGUI is built on the Model Context Protocol. It registers as a standard MCP server, so any MCP-speaking agent or runtime can call it with a single HTTP entry in its MCP config; there is no proprietary integration surface to adopt. UI requests and the interaction events that flow back both ride ordinary MCP messages, which is what keeps GGUI LLM-agnostic and framework-agnostic.
How do I use hosted GGUI?
Sign in to the GGUI console at console.ggui.ai with Google, GitHub, or email to create apps, mint connector keys, and top up credit. Start with $5 of welcome credit. No card. Then pay as you go: 15¢ per render, 2¢ per cache hit. Point your agent’s MCP config at the hosted endpoint and it renders generative UI for every tool call. It runs the same open protocol as the self-hosted server, so you can move between them any time.
What does hosted GGUI cost?
Start with $5 of welcome credit. No card. Then pay as you go: 15¢ per render, 2¢ per cache hit. Your own model key is 1¢ per render on the platform lane, drawn from the same prepaid credit, so a $0 balance refuses those renders too; a generation that fails is never charged. Same rates for every account, no subscription of any kind: top up $10, $50 or $100, or any amount from $5 to $1,000, whenever you like; purchased credit never expires. Larger models are enabled per account on request, not by default, and priced per model on top of the render rate. Enterprise is a conversation: enterprise@ggui.ai. Full details at ggui.ai/pricing.
What happens to my data on hosted GGUI?
Renders and their event logs are kept until you delete them: there is no automatic expiry by default, so a card can always be reopened, and an agent can bound any single render with a per-render TTL. Your renders only ever feed your own app’s blueprint pool; we don’t train models on your content, and platform-routed generation only uses providers whose terms prohibit training on API content (traffic on your own provider key runs under your agreement with that provider). Hosted renders and their data are stored in AWS us-east-1; generation prompts go to the model provider you route to, Anthropic by default. Generated views run in a sandboxed iframe, ours where we host it and the host’s where it embeds them, and on our live channel every action is validated against the render’s declared contract before it reaches your agent. The binding statement is the Privacy Policy at ggui.ai/privacy; the mechanics and their limits are on docs.ggui.ai/hosted/trust.
Which agent frameworks work with GGUI?
Claude Agent SDK, OpenAI Agents, Google ADK, guuey-sdk (composed) are tested and ship first-party samples in the repo. LangGraph and Mastra, like any other MCP-speaking runtime, work through the same single HTTP MCP entry, with no first-party sample required.
Can we build GGUI into our own product?
Yes. The protocol and runtime are Apache 2.0: embed them in your own service, self-hosted or via hosted GGUI, with no lock-in. For first-class integrations, framework partnerships, enterprise hosted terms, or design partnership while the protocol is early, email enterprise@ggui.ai.
Who's behind GGUI?
GGUI is developed in the open by Loqu, Inc. (loqu.co), backed by Hashed. The protocol was authored by Wanseob Lim, previously of the Ethereum Foundation.

More in the repo ↗ and discussions ↗.

Still reading? That’s the signal.

Book a demoStart free in the console ↗