SparkUI

The only way to give AI agents interactive UIs — through just a URL

Rich, ephemeral web pages generated on demand. No installs. No accounts. Pages self-destruct when done.

Open Source 11 Templates npm ready
npm install @limeade-labs/sparkui Click to copy

AI deserves better than text walls

😤 The Problem

AI agents are stuck in text. Macro trackers as emoji bars. Checkout flows as "paste your card number in chat." Workout timers as… countdown text?

Rich interactions squeezed into a text box. Users deserve better. Agents can do better.

The Solution

SparkUI generates real, interactive web UIs on demand. A link in chat → rich UI in browser → results back to the agent.

No app installs. No accounts. No setup. Just a URL that works everywhere and self-destructs when done.

See the difference

AI agents solve real problems. SparkUI gives them the UI to do it right.

💳 Payment in Chat
Agent: Ready to check out! Total is $29.99.
Agent: Please paste your card number here.
User: 4242 4242 4242 4242
User: Exp: 12/27, CVV: 123
// Card data in plaintext. In chat history. Forever.
💳 Ephemeral Checkout
Agent: Here's your secure checkout:
→ sparkui.dev/s/xK9m2p

// Real checkout form. SSL encrypted.
// Self-destructs after payment.
// Zero card data in chat history.
⏱️ Workout Tracking
Agent: Push-ups! 30 seconds. Ready?
Agent: 30... 29... 28...
Agent: 27... 26...
User: Can you just send them faster?
Agent: 25... 24... 23...
// 30 messages for one exercise. No audio. No visual.
⏱️ Interactive Timer
Agent: Workout ready! 3 rounds, 3 exercises:
→ sparkui.dev/s/qR7wYn

// Visual countdown with audio cues.
// Pause, skip, adjust on the fly.
// Agent gets results when you're done.
✅ Team Decisions
Agent: Budget request: $15k for Q2 marketing.
Agent: Details: Social media campaign based on Q1...
Agent: Reply "approve", "reject", or "changes"
User: approve but can we reduce to 12k?
Agent: I'll note that. Was that approve or changes?
// Ambiguous. No structured data. Lost in scroll.
✅ One-Click Approval
Agent: Budget approval needed:
→ sparkui.dev/s/aP3kLm

// Clean approval form with all details.
// Approve / Reject / Request Changes buttons.
// Comment field. Confirmation dialog.
// Structured response back to agent.

Professional icons, not emoji

AI-generated UIs have a tell: emoji everywhere. It instantly screams "a bot made this." SparkUI fixes that automatically — one line of config replaces every emoji with a crisp, professional SVG icon. Your AI-built pages look hand-crafted.

Before

💳 📅 ⚙️ 🔍 🔔 ⚠️ 📊

Platform-dependent, inconsistent, unprofessional

After

Crisp, consistent, color-coded SVGs — 208 icons included

Style & Color Options

Choose the variant that fits your brand. All configurable via a single option.

Outline

variant: "outline"

Duotone Default

variant: "duotone"

Filled

variant: "filled"

Custom Colors

colorMap: {...}
Powered by @limeade-labs/sparkui-icons — also available as a standalone npm package

See it in action

These buttons hit a live SparkUI server and generate real ephemeral pages. Try them — they'll self-destruct in an hour.

Macro Tracker

Daily nutrition tracking with calorie & macro progress bars, meal logging, and totals.

Checkout Flow

Secure ephemeral checkout with product details, quantity, promo codes, and payment form.

⏱️

Workout Timer

Interactive exercise timer with rounds, rest periods, exercise checklists, and audio cues.

Feedback Form

Multi-field form with star ratings, text inputs, selects, and real-time validation.

Poll / Voting

Real-time polls with bar chart results, single or multi-select, and auto-close support.

Shopping List

Categorized, checkable shopping list with real-time sync and collaborative editing.

Calendar

Day and week views with color-coded events, detail modals, and today highlighting.

Approval Flow

Request approval with approve/reject/changes buttons, comments, and confirmation dialogs.

Comparison

Side-by-side product comparison with feature matrix, pros/cons, and selection.

Compose custom pages from 15+ built-in components — mix and match to build exactly what you need.

json
// POST /api/push — compose multiple components
{
  "components": [
    { "type": "header", "title": "Order #4821" },
    { "type": "key-value", "pairs": {
        "Status": "Processing",
        "ETA": "March 18"
    }},
    { "type": "progress", "value": 65, "label": "Fulfillment" },
    { "type": "buttons", "items": [
        { "label": "Track Package" },
        { "label": "Contact Support" }
    ]}
  ]
}

Three steps. Zero friction.

Agent pushes UI

Your AI agent generates a page — pick a template or compose from 15 components — and pushes it via the REST API.

User clicks link

User gets a URL in chat. One click opens a polished, interactive page in their browser. No installs. No accounts.

Results flow back

User actions stream back to the agent via WebSocket in real-time. The agent responds, adapts, and continues the conversation.

┌─────────────┐    POST /api/push    ┌───────────────┐    GET /s/:id    ┌─────────────┐
│             │ ───────────────────▶  │               │  ◀───────────── │             │
│    Agent    │                       │    SparkUI    │                  │   Browser   │
│  (AI/MCP)  │  ◀── WebSocket ─────  │    Server     │  ── WebSocket ▶ │   (User)    │
│             │   completion events   │               │   user actions  │             │
└─────────────┘                       └───────────────┘                 └─────────────┘
      

Wire it up in 2 minutes

SparkUI works with every major AI platform. OpenClaw users get it with zero config — everyone else just needs an MCP config or a single API call.

Get a SparkUI server

Coming Soon

OpenClaw Plugin

SparkUI will run alongside your OpenClaw gateway — one command, zero extra hosting, auto-configured.

openclaw plugins install @limeade-labs/sparkui

Auto-configures URL, token, and skill. Follow progress →

One-Click Deploy

Deploy your own instance to any cloud platform in one click.

Run Locally

Try it out on your machine first. No account needed.

npx @limeade-labs/sparkui

Starts on port 3456. Token auto-generated.
Use ngrok or Tailscale to expose it.

Connect your AI

terminal
# Step 1: Copy the SparkUI skill into your agent workspace
cp -r node_modules/@limeade-labs/sparkui/skills/sparkui ~/clawd/skills/

# Step 2: Set your SparkUI server URL and token
openclaw config set sparkui.url https://your-sparkui-server.com
openclaw config set sparkui.token spk_your_token

# Your agent now has sparkui_push and sparkui_compose tools.
# Works across every channel — Slack, Discord, Telegram, iMessage, WhatsApp.

# 🔜 Soon: `openclaw plugins install @limeade-labs/sparkui`
#    One command. Auto-hosts the server, generates token, installs skill.
claude_desktop_config.json
// Settings → Developer → Edit Config
{
  "mcpServers": {
    "sparkui": {
      "command": "npx",
      "args": ["@limeade-labs/sparkui", "mcp"],
      "env": {
        "SPARKUI_URL": "https://your-sparkui-server.com",
        "SPARKUI_TOKEN": "spk_your_token"
      }
    }
  }
}

// Restart Claude. Try: "Create a poll asking my team about lunch"
terminal
claude mcp add sparkui \
  -e SPARKUI_URL=https://your-sparkui-server.com \
  -e SPARKUI_TOKEN=spk_your_token \
  -- npx @limeade-labs/sparkui mcp

# Try: "Build me a feedback form for the new feature"
Custom GPT Actions
// Configure → Actions → Add Action
// Import OpenAPI spec from your server:

Schema URL: https://your-sparkui-server.com/api/openapi.json

// Set Authentication → API Key → Bearer token
// Header: Authorization | Value: Bearer spk_your_token

// Your GPT gets: push (templates), compose (components), templates (list)
// Try: "Create a checkout page for my $29.99 product"
Function Calling
// Add SparkUI as a function declaration:
{
  "name": "sparkui_push",
  "description": "Generate an interactive web UI",
  "parameters": {
    "template": { "type": "string" },
    "data": { "type": "object" }
  }
}

// Handler forwards to: POST https://your-server.com/api/push
// Returns a URL → Gemini shares it with the user
.cursor/mcp.json
{
  "mcpServers": {
    "sparkui": {
      "command": "npx",
      "args": ["@limeade-labs/sparkui", "mcp"],
      "env": {
        "SPARKUI_URL": "https://your-sparkui-server.com",
        "SPARKUI_TOKEN": "spk_your_token"
      }
    }
  }
}

// Also works with .windsurf/mcp.json — same format.
// Try: "Create a comparison table for these 3 API options"
any language
curl -X POST https://your-sparkui-server.com/api/push \
  -H "Authorization: Bearer spk_your_token" \
  -H "Content-Type: application/json" \
  -d '{
    "template": "poll",
    "data": {
      "question": "Where should we eat?",
      "options": ["Thai", "Pizza", "Sushi", "Tacos"]
    }
  }'

# → { "url": "/s/abc123", "fullUrl": "https://..." }
# Share the link. Listen on WebSocket for results.

Purpose-built for AI agent UIs

Other approaches exist. None were designed for this.

Raw HTML Generation

  • Slow — agent generates full markup
  • Security risks (XSS, injection)
  • No real-time data flow back
  • Pages persist indefinitely

Native Apps

  • Requires download & install
  • App store approval delays
  • Heavy for one-off interactions
  • Platform-specific builds

Web Frameworks

  • Requires developer setup
  • No agent integration built-in
  • Overkill for ephemeral UIs
  • Persistent infrastructure needed

SparkUI

  • One API call → full interactive UI
  • Secure by default, sandboxed
  • Real-time WebSocket data flow
  • Self-destructing, zero cleanup

One request. Real UI.

Push an interactive page in a single API call.

bash
curl -X POST https://sparkui.dev/api/push \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "template": "checkout",
    "data": {
      "product": {
        "name": "Flux Capacitor",
        "price": 1985.00,
        "image": "⚡"
      }
    }
  }'

# → { "url": "/s/abc123", "expiresAt": "..." }
javascript
// Node.js — push + listen for results
const res = await fetch('https://sparkui.dev/api/push', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${token}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    template: 'feedback-form',
    data: { fields: [
      { type: 'rating', label: 'Experience', max: 5 },
      { type: 'text', label: 'Comments' }
    ]}
  })
});

const { url, pageId } = await res.json();
// Connect WebSocket to receive user submissions
const ws = new WebSocket(`wss://sparkui.dev/ws/${pageId}`);
ws.on('message', (data) => console.log('User submitted:', data));

Built in the open. Built to last.

11 Templates
15+ Components
7 Integrations
MIT Licensed
Built by Limeade Labs — building developer tools for the agentic era
Star on GitHub — contributions welcome