rui
Early access

Generative UI platform · Early access

Interfaces
for humans.

AI is starting to answer with screens instead of paragraphs. We build the parts those screens are made from, the tests that prove they work for the person using them, and a lab for working out what comes next.

    Built on open protocols
    • MCP
    • WebMCP
    • AG-UI
    • A2UI
    • MCP Apps

    The shift

    Software is learning to draw its own screens.

    The answer is right, but it arrives as a block of text. So models are starting to build the interface themselves, on the spot. It's a big shift, and right now nobody owns the three problems that come with it.

    Update your plan?

    You can change this at any time.

    BackCancel
    on click DELETE /account not in the screenshot

    Platform

    One system, from the first component to the final check.

    Four parts that work alone and work better together. Each one is built so the person, not the model, is who the interface serves.

    1. Compose
    2. Generate
    3. Prove
    4. Connect
    ComposePreview

    Components people and agents can both use. A person sees a table they can sort. An agent sees a tool with typed inputs. Same component, so the agent never guesses what a button does.

    For buildersOne prop turns a component into an agent tool. A budget keeps the agent focused: 120 capabilities declared, 12 in view.

    GenerateIn development

    Describe it, get a working interface. Live, on-brand, and yours to refine by talking to it, assembled only from components you've approved.

    For buildersStructured specs against your registry for safety, or sandboxed code for freedom. Your design tokens apply to both.

    ProvePreview

    Every generated screen is tested before a person sees it. We open it in a real browser, do the task, and pause each action just before it takes effect.

    For buildersGrades effects, not pixels. Hard gates no score can buy back. Runs locally, zero dependencies, no API key.

    ConnectIn development

    Your interfaces, in the chat you already use. Connect your component library to your team's assistants so they answer with your UI instead of a wall of text.

    For buildersBuilt on open protocols. We sit on top of them rather than adding another one.

    Proof

    Same dialog. Opposite verdicts.

    These two pages show the same confirmation dialog, down to the last byte. A person can't tell them apart, and neither can a screenshot. So we don't judge how a page looks. We press the button and look at what it's about to do.

    What a screenshot sees

    Identical pixels. Nothing to flag.

    What rui sees

    Page A · on clickPOST /account/soft-delete

    Support can restore it. The confirmation matched what the action needed.

    PASS safe to show

    Page B · on clickDELETE /account

    Gone for good. Something that permanent needs a person outside the conversation to approve it.

    BLOCK stopped before it happened

    Every verdict comes with its evidence and replays exactly, every time.

    • Effects, not pixelsWe read what an action will do, not what it looks like.
    • Hard gatesAnything irreversible waits for a person. No score overrides it.
    • Runs on your machineNo API key, and nothing leaves unless you connect a model.

    Who it's for

    For the people on both sides of the screen.

    If you use AI

    Ask a question and get something you can use: a chart you can filter, a form you can finish, a button that does what it says. And nothing permanent happens without you.

    If you run a product

    Let AI build screens on the fly without giving up your brand, your accessibility bar, or your idea of what's safe to show a customer.

    If you build

    Typed components, real-browser verdicts, and open protocols. Use one part or all four, alongside the model and stack you already have.

    Open research

    The Lab

    We do our research in the open. Every run leaves a record of the request, the screen, what it tried to do, and the verdict. Those records are how the next generation of interface models learns.

    • EXP-001Working demo

      Grade the effect, not the pixels

      Two identical screens that do very different things. What does it take to tell them apart before a user finds out?

    • EXP-002Running

      How many tools can an agent hold?

      Agents get worse as you give them more tools. We're measuring where that happens and which few tools deserve a place.

    • EXP-003Working demo

      What the agent sees

      An overlay that shows a page the way an agent reads it.

    • EXP-004Running

      Interfaces that learn from their verdicts

      Generate many, test all of them, keep the best, and train on the difference. Can a small model learn one company's taste?

    • EXP-005Notes

      The reversibility ladder

      Undo, support can undo, costly to undo, can't be undone. How much confirmation should each step up require?

    • EXP-006Sketch

      Answers that aren't paragraphs

      When should an assistant reply with an interface instead of text? We're looking for the line, and for when it moves.

    Write-ups go to the early access list first.

    Principles

    What we hold ourselves to.

    1. The interface is the answer. If someone has to read four paragraphs to do one thing, the answer came in the wrong shape.
    2. Judge what it does, not how it looks. A good-looking screen that does the wrong thing is worse than a plain one that does the right thing.
    3. People keep the last word. Anything that can't be undone waits for a person to approve it.
    4. Your brand is a rule, not a vibe. Generated screens should be recognisably yours, every time.
    5. Open standards over walled gardens. Interfaces should travel between models, apps and chats instead of being locked into one.

    FAQ

    Questions

    What is a generative interface?

    An interface that an AI puts together at the moment you need it. Instead of replying with paragraphs, it replies with a chart you can filter, a form you can finish, or a button that does the job.

    Is this only for developers?

    No. Developers get the building blocks, but the point is the person on the other side of the screen: people using AI, and the product and design teams responsible for what they see.

    How is this different from other generative UI tools?

    Most tools focus on rendering whatever a model asks for. We cover the whole loop: components that both people and agents can use, generation that stays inside your design system, and proof in a real browser before anything reaches a user.

    Which models and protocols does it work with?

    We sit on top of the protocols rather than inventing another one. The work already speaks MCP, WebMCP, AG-UI, A2UI and MCP Apps, and it isn't tied to one model provider.

    Does my data leave my machine?

    The testing engine runs locally and needs no API key. Nothing leaves your machine unless you choose to connect a model.

    When can I use it?

    Early access opens in waves. Join the list and we'll email you once, when your spot is ready.

    Early access

    The next screen you use might be built on the spot. Let's make it one you can trust.