RevealUI

Agentic business runtime.

People. Content. Offers. Payments. Agents. Five primitives for humans and agents, one deployment, one runtime.

Documentation | Quick Start | Pro | Contributing

---

RevealUI is an open-source runtime that ships the business logic layer every software product needs: auth, content, products, billing, and AI agents. Pre-wired and development-hardened. You start on day one with a running business. Your agents start on day one with a runtime they can operate on. Same permissions, same API, and data model.

Canonical definition: docs/WHAT_IS.md.

What you get on day one

npx create-revealui@latest my-business
cd my-business
pnpm dev

Public get-started paths that are live today:

1. npx create-revealui@latest
2. GitHub templates (Use this template): starter, basic-blog, portfolio, e-commerce
3. Apify governed-agent-run — pay-per-event. Receipt verification is $0.00001, not free.
4. Marketing templates page: revealui.com/templates — Deploy to Vercel for the four Next.js GitHub twins. starter-native has no twin. There is no live vercel.com/templates listing.

Open http://localhost:4000/admin.

You have:

• User accounts: sign up, sign in, password reset, sessions, RBAC, rate limiting, brute force protection
• Content management: define collections in TypeScript, get a full REST API, admin UI, and MCP tools instantly
• Billing: Stripe checkout, subscriptions, trials, webhooks, grace periods, and a billing portal
• Admin dashboard: manage users, content, billing, and settings out of the box
• 68 UI components: built with Tailwind CSS v4, zero external UI dependencies
• 14 MCP servers: agents discover and use your business data through the same API humans use
• Type-safe throughout: Zod schemas shared between client, server, database, and agent tools

No assembly required. Define your data once. Humans manage it through the dashboard, agents operate on it through MCP. Same permissions, same audit trail.

The five primitives

Primitive	For you	For your agents
People	Session auth, RBAC + ABAC, rate limiting, GDPR compliance	Same RBAC governs agent access. Every action auditable.
Content	Collections, rich text (Lexical), media, draft/live, REST API	Collections auto-exposed as MCP tools. No integration step.
Offers	Product catalog, pricing tiers, usage tracking	Feature gates control which agent capabilities unlock.
Payments	Stripe checkout, subscriptions, webhooks, billing portal	Same Stripe primitives, available to agents.
Agents	AI agents, open-model inference, task history (Pro)	A2A protocol, CRDT memory, 14 MCP servers.

Open-model first

The Agents primitive ships with open-model defaults. No proprietary API keys required, no API bill that scales with usage.

• Ollama — local model runner; the standard developer-machine path.
• Ubuntu Inference Snaps — US-origin model runtimes for production. sudo snap install gemma3 (or gemma4, nemotron-3-nano, nemotron-3-nano-omni). Non-US catalog snaps are rejected in product code.
• Pluggable provider adapters — Claude, OpenAI, and others available as opt-in adapters. The fleet runtime never imports any provider SDK by default; you wire whichever model you want.

Verifiable: git grep -l "@anthropic-ai/sdk" packages/ returns nothing inside @revealui/* packages. The runtime is provider-agnostic by contract.

Design principles

Six principles that give you a tested starting point for every architectural decision. Not the only way, a way that works. Evolve it as you grow:

Principle	What it means
Justifiable	Every default earns its place. No magic, no hidden complexity, no decisions you can't explain to your team.
Orthogonal	Clean separation of concerns across 33 packages. Use what you need, replace what you don't. Zero circular dependencies.
Sovereign	Your infrastructure, your data, your rules. Deploy anywhere. Fork anything. No vendor holds your business hostage.
Hermetic	Auth doesn't leak into billing. Content doesn't tangle with payments. Sealed boundaries, clean contracts between every layer.
Unified	One Zod schema defines the truth. Types, validation, and API flow from database to server to UI with zero drift.
Adaptive	AI agents, MCP servers, and workflows are built into the foundation. Open-model inference, sovereign by design, evolving with your business.

Define your business data

Add a collection. Get an API, admin UI, MCP tool, and TypeScript types, automatically.

import { defineCollection, defineField } from "@revealui/core";

const Products = defineCollection({
  slug: "products",
  fields: [
    defineField({ name: "name", type: "text", required: true }),
    defineField({ name: "price", type: "number" }),
    defineField({ name: "description", type: "richText" }),
    defineField({
      name: "status",
      type: "select",
      options: ["draft", "active"],
    }),
    defineField({ name: "owner", type: "relationship", relationTo: "users" }),
  ],
  access: {
    read: ({ req }) => !!req.user,
    create: ({ req }) => req.user?.role === "admin",
  },
});

GET /api/products is live. The admin UI is live. The MCP tool is discoverable. The TypeScript types are generated. Humans manage products through the dashboard. Agents query and create through the same API.

Pro: AI for your business

The Pro tier adds AI agents and automation that work on your behalf:

• AI agent system (beta — works in staging, production usage is early): build and deploy purpose-built agents for your workflows
• MCP framework: hypervisor, adapter framework, and tool discovery for connecting agents to external services
• Open-model inference: Ubuntu Inference Snaps (canonical default — Studio lifecycle pending), Ollama, and open source models via the RevealUI harness. sudo snap install gemma3 for US-origin local AI (or gemma4 / nemotron-3-nano). No proprietary APIs, no vendor lock-in, zero API bills
• Task history: every agent action logged, auditable, and visible in the dashboard
• Editor config sync: generate and sync settings for Zed, VS Code, Cursor, and Antigravity

Pro packages are source-available under the Functional Source License (FSL-1.1-MIT). You can read, modify, and self-host. The license converts to MIT after 2 years. Install with pnpm add @revealui/ai.

Tiers

Tier	Price	What you get
Free	$0	Full OSS core: people, content, offers, payments, admin
Pro	$49/mo	AI agents, AI memory, signed audit receipts, MCP framework, advanced sync, RevVault desktop + rotation engine
Max	$99/mo	Unattended inference, higher limits
Enterprise	inquire / Contact sales	License + studio support (you self-host). SSO (operator preview, not customer-walked — #449). Domain-locked. Not a Studio-operated customer VM.

Apps

App	Framework	Purpose
server	Hono	REST API with OpenAPI + Swagger
admin	Next.js 16	Admin dashboard + content management
docs	Vite + React	Documentation site
marketing	Vite + React	Marketing site (revealui.com)
license-signer	Hono	Internal license-signing service
rsc-poc	Next.js	In-tree RSC experiment (not a customer app)

The RevealUI Studio agency site (revealuistudio.com) lives in RevealUIStudio/agency — separate repo, consumes @revealui/{router,presentation,core,contracts} via npm.

Packages

OSS Packages (MIT) — 26

Package	Purpose
@revealui/core	Runtime engine, REST API, auth, rich text, plugins
@revealui/contracts	Zod schemas + TypeScript types (single source)
@revealui/db	Drizzle ORM schema (124 tables) on NeonDB (Postgres)
@revealui/auth	Session auth, password reset, rate limiting
@revealui/presentation	68 UI components (Tailwind v4, zero ext deps)
@revealui/openapi	OpenAPI route helpers and Swagger generation
@revealui/router	Lightweight file-based router with SSR
@revealui/config	Type-safe environment configuration
@revealui/utils	Logger, DB helpers, validation

Pro (Commercial)

Package	Purpose
@revealui/ai	AI agents, CRDT memory, LLM providers
@revealui/engines	Incubating optional barrel for the five primitives (not the app entry; private)
@revealui/harnesses	AI harness adapters and workboard coordination
@revealui/mcp	MCP hypervisor, adapter framework, tool discovery
@revealui/services	Stripe (billing + circuit breaker), transactional email (Gmail API)

Internal Packages (no public license, build tooling) — 2

Package	Purpose
@revealui/scripts	Shared monorepo script utilities. Build tooling, not for external consumption
@revealui/apify-actor-governed-run	Private Apify actor that returns a signed receipt of an agent run

Tech stack

Layer	Technology
Frontend	React 19, Tailwind CSS v4
Backend	Node.js 24, Hono, REST + OpenAPI
Database	NeonDB (Postgres), Drizzle ORM
Auth	Session-based, bcrypt, RBAC + ABAC
Rich Text	Lexical editor
Sync	ElectricSQL (experimental)
Billing	Stripe (checkout, subscriptions, webhooks)
Desktop	Tauri 2
TUI	Go, Bubble Tea
Testing	Vitest, Playwright
Tooling	pnpm, Turborepo, Biome, TypeScript 6
Dev env	Nix flakes + direnv

Prerequisites

• Node.js 24+
• pnpm 10+
• PostgreSQL database (NeonDB free tier works)
• Stripe account (for billing features)

Quick start

Secrets live in RevVault. Do not treat apps/admin/.env.example as the happy path. See docs/fleet/revvault.md and docs/SECRETS.md (maintainer).

# If you have RevVault on this machine:
revvault export-env   # materializes env from the vault; direnv loads it

Option A: Local development (recommended)

git clone https://github.com/RevealUIStudio/revealui.git
cd revealui
pnpm install

# Without RevVault: copy the repo-root template (not apps/admin/.env.example)
cp .env.template .env.development.local
# Set POSTGRES_URL, REVEALUI_SECRET (min 32 chars),
# REVEALUI_PUBLIC_SERVER_URL=http://localhost:4000

# Initialize database
pnpm db:migrate
pnpm db:seed

# Start admin dashboard + API
pnpm dev:app    # Admin (port 4000) + API (port 3004)

Three dev modes:

• pnpm dev:app: Admin + API (recommended for most work)
• pnpm dev:admin: Admin only (if API already running)
• pnpm dev: All apps in parallel (heavy)

Option B: Docker Compose

cp .env.production.example .env
# Edit .env with your values
docker compose up -d

Services: PostgreSQL (5432), API (3004), Admin (4000), Marketing (3000).

Option C: Dev Containers

Open in VS Code or GitHub Codespaces. The .devcontainer/ config handles everything.

Platform	Recommended setup
Linux / WSL	Nix flakes + direnv (flake.nix)
macOS	Nix flakes + direnv (flake.nix)
Windows	WSL 2 (recommended) or Dev Containers (.devcontainer/)

Project structure

revealui/
├── apps/
│   ├── server/     # Hono REST API (port 3004)
│   ├── admin/      # Admin dashboard + content management (port 4000)
│   ├── docs/            # Documentation site (port 3002)
│   ├── marketing/       # revealui.com marketing site (port 3000)
│   ├── license-signer/  # Internal license-signing service
│   └── rsc-poc/         # In-tree RSC experiment
├── packages/       # 26 OSS + 5 Pro + 2 internal = 33 packages
├── docs/           # guides + reference
└── scripts/        # CI gates, release tooling, dev tools

Documentation

• Build Your Business: End-to-end tutorial: scaffold, collections, pricing, billing, deploy
• What is RevealUI?: Canonical definition, tiers, feature matrix
• Quick Start: From zero to running app
• Plugins: Config-transform plugins in @revealui/core
• Design Principles: Six engineering principles: Justifiable, Orthogonal, Sovereign, Hermetic, Unified, Adaptive, and the evidence behind each
• Architecture: How the pieces fit together
• Harness Protocol: Agent-tool coordination layer shipped in @revealui/harnesses
• Pro: AI features, MCP, marketplace, and trust controls
• Database Guide: Schema, migrations, queries
• Auth Guide: Authentication, sessions, RBAC
• Admin Guide: Collections, fields, access control

Contributing

Read CONTRIBUTING.md first. Then:

pnpm test       # run tests
pnpm lint       # lint and format
pnpm typecheck  # type check
pnpm gate       # full CI gate (runs before push)

Community

• GitHub Discussions
• GitHub Issues

Sponsors

RevealUI is MIT-licensed and free to use. Sponsorship funds development, documentation, and community support.

• Individuals: github.com/sponsors/RevealUIStudio
• Businesses: revealui.com/sponsor for Gold and Platinum tiers (logo placement, office hours, roadmap input)

License

This repository is dual-licensed:

• OSS packages (most of the repo, including every @revealui/* package without its own in-package LICENSE file): MIT — see LICENSE.
• Pro packages (@revealui/ai, @revealui/engines, @revealui/harnesses, @revealui/mcp, @revealui/services): Functional Source License v1.1 with MIT Future License (FSL-1.1-MIT) — source-available for non-competing use, automatically converts to MIT on each package's Change Date (~2 years from first FSL publish). See LICENSE.commercial for the dual-license explainer and each Pro package's LICENSE file for canonical terms.

For commercial licensing alternatives or licensing questions: [email protected].

---

Built by RevealUI Studio — the agency. Operated by REVEALUI STUDIO L.L.C. (Tennessee).