Sneak peek — you found hosted ggui early · official launch soon

For Agentic App Builders

read as .md

What an agentic app is

An agentic app is a product you have already shipped, driven by an agent instead of only by hands. The user asks for the outcome — “refund last month’s invoice for this customer” — and the agent works the real flows of your app to get there, in typed calls rather than simulated clicks.

The part that matters commercially is what it does not require: a frontend rewrite. Your React app, your Rails views, your existing routes and permissions all stay. Agent access arrives as a second, parallel surface onto the same flows, not as a replacement for the one your users already know.

Today agents reach existing SaaS through three unreliable layers: reading screenshots (vision models reasoning about pixels — brittle, slow, no typed I/O), browser automation (Playwright scripts that snap the moment a button moves, with no way for the agent to learn the contract changed), and official APIs (when they exist, and only for the slice they cover — most production apps keep a large share of their behavior in the UI). What’s missing between an agent and an app it did not generate is a typed contract.

The adapter approach

You add a ggui adapter beside your existing app rather than inside it. The adapter reads your app’s routes and describes them in the protocol’s own terms: each navigable route becomes a render with a typed contract, form fields become actionSpec entries (typed inbound actions that drive turns), visible state becomes contextSpec (read-only state the agent observes), and browser-only libraries you depend on — Stripe Checkout, Mapbox, a calendar picker — are wrapped as gadgets so a model knows how to compose with them.

From the agent’s side, nothing is special about your app. It drives it through ggui_handshake, ggui_render, and ggui_consume exactly as it drives a freshly generated ggui UI: same MCP wire, same contract guarantees, same failure modes. From your users’ side, nothing changed at all — they keep clicking the buttons that were always there.

What you’d write

The provisional shape is a ggui.app.json next to your existing app config:

{
  "name": "my-saas",
  "routes": [
    {
      "path": "/invoices/new",
      "intent": "create an invoice",
      "agentCapabilities": {
        "tools": {
          "createInvoice": {
            "toolInfo": { "inputSchema": { "$ref": "./schemas/invoice.json" } }
          }
        }
      },
      "actionSpec": {
        "submit": {
          "label": "Create invoice",
          "schema": { "$ref": "./schemas/invoice.json" },
          "nextStep": "createInvoice"
        }
      },
      "contextSpec": {
        "currentDraft": { "schema": { "$ref": "./schemas/invoice-draft.json" } }
      }
    }
  ]
}

Your app code stays as-is. An agent runtime can now discover /invoices/new from the adapter’s catalog, ggui_handshake against its contract, and ggui_render with a typed payload — no clicking around. (Exact wire shape for app-catalog lookup is part of the SDK’s in-design surface.)

Where this is built: ggui vs guuey

The hosted product this track becomes is guuey’s — a separate agent-hosting platform, at guuey.com, built on the ggui protocol. ggui (this site) documents the protocol; guuey productizes hosting. guuey is not a paid tier of ggui, and it is not run from this site.

The split is clean and worth internalizing before you plan against it:

ggui (this site) is the open protocol and its hosted deployment. It defines the contract, the ggui_* tool surface, and the render lifecycle, and it documents both the hosted and self-hosted ways to run it. The spec and the SDKs are open source.
guuey productizes hosting on top of that protocol: running your agent, the operational surface around it, and — for this track — the hosted service that keeps an adapter pointed at your live app.

The protocol side of the adapter (contracts, gadgets, the wire shape above) belongs to ggui and will be documented here. The hosted service that runs it for you belongs to guuey and will be documented there. If a future page tells you an agentic-app feature is “part of ggui”, check which of those two it actually is.

Three scenarios this unlocks

Your support agent drives the app for the customer. “Refund last month’s invoice for customer X” → agent navigates to /invoices/, finds the row, calls refund with the typed payload. No human-in-the-loop browsing.
Your sales engineer runs an agent-narrated demo. During a prospect call, the agent narrates while driving the form in real-time. The prospect sees the same UI any user sees, but the agent’s typed actions land like a polished guided tour.
Power users hand work off to their AI. “I have 40 of these to fill in — can my AI do it?” The AI has a typed surface to drive, not pixels to scrape.

What’s shipping when

Component	Owner	Status
ggui protocol (this site)	ggui	Live
Building a ggui-native agent	ggui	Live
Agentic App SDK (the adapter you’d add to your app)	ggui	In design
Hosted service that runs an adapter against your live app	guuey	In design
Reference adapters for Next.js / Rails / Django	ggui	Planned
Reference adapters for legacy stacks (Java EE, Drupal, …)	ggui	Planned

No dates. Real engineering work, not a marketing roadmap.

Waitlist

The adapter SDK half of this track is still in design here. The guuey platform is in open public beta at guuey.com — anyone can deploy a hosted agent today. If the hosted product is what you want, start there.

If it’s the adapter itself you need — you’d rather run it yourself against the open protocol — drop your email below. We’ll write when the first adapter ships and we have an early-access slot to fill.

How ggui works — the protocol’s five moments. The gguify pattern reuses the same handshake → render → interact → consume → reopen loop, just driven by your app’s routes instead of LLM-generated UI.
Glossary — actionSpec, contextSpec, gadget, tool, blueprint.
The dev loop — how a ggui agent moves between a local runtime and hosted ggui. The adapter track inherits the same split.
For LLM agents — machine-readable resources, including this page at /agentic-app-builders.md.