Lets an AI coding agent read and write an infinite-canvas design board: create projects, generate and edit HTML screens, and export prototypes.
Also known as Bearisbug/Quilt, quilt-canvas
- Stars
- 106
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Nov 4, 2026
- License
- Apache-2.0
What is Quilt MCP?
Quilt lets an AI coding agent read and write an infinite-canvas design board: create projects, generate and edit HTML screens, and export prototypes.
Summary generated from the project's README
About Quilt MCP server
Designing multi-screen application prototypes by describing them to an AI agent is what Quilt enables. This tool provides an infinite canvas where coding agents can read and write HTML screens, manage design systems, and build interactive prototypes. It operates entirely on your local machine using a single process, storing all data in your home directory without requiring a cloud backend or user accounts.
Developers connect their agents via MCP over Streamable HTTP, providing 57 specialized tools and 7 resources. You can use your existing Claude subscription, an Anthropic or Gemini API key, or an OpenAI-compatible endpoint to power the generation process. The system manages everything from generating 4–6 screen flows to managing shared components like sidebars and tab bars. Because it uses a local PGlite database, your design data remains private and under your control.
What you can do with it
- 1Generate multi-screen app flowsAsk an AI agent to create a complete application flow with several consistent HTML screens on a canvas.
- 2Iterative component editingDirect an agent to modify specific elements or blocks within a generated screen to refine the UI.
- 3Rapid prototyping and exportingTurn a collection of designed screens into a clickable prototype that can be exported as a single offline file.
- 4Sketching individual componentsUse the sketchbook feature to draft one-off UI elements before moving them into a formal project.
Written from the project's README. Every use case is checked against a quote from it.
How to install Quilt MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall Quilt MCP in Claude Code
$ claude mcp add quilt -- npx -y quilt-canvasInstall Quilt MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"quilt": {
"command": "npx",
"args": [
"-y",
"quilt-canvas"
]
}
}
}Install Quilt MCP in VS Code
.vscode/mcp.json
{
"servers": {
"quilt": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"quilt-canvas"
]
}
}
}Install Quilt MCP in VS Code CLI
$ code --add-mcp '{"name":"quilt","type":"stdio","command":"npx","args":["-y","quilt-canvas"]}'Install Quilt MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"quilt": {
"command": "npx",
"args": [
"-y",
"quilt-canvas"
]
}
}
}Install Quilt MCP in Codex
$ codex mcp add quilt -- npx -y quilt-canvasInstall Quilt MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.quilt] command = "npx" args = ["-y", "quilt-canvas"]
Install Quilt MCP in Gemini CLI
$ gemini mcp add -s user quilt npx -- -y quilt-canvasInstall Quilt MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"quilt": {
"command": "npx",
"args": [
"-y",
"quilt-canvas"
]
}
}
}Configuration
ANTHROPIC_API_KEYGEMINI_API_KEYLLM_DRIVER
| Name | Description | |
|---|---|---|
| ANTHROPIC_API_KEY | — | |
| GEMINI_API_KEY | — | |
| LLM_DRIVER | — |
Automated checks
Ran Nov 12, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachablePass
- Open source license (OSI)Pass
- Commit or release in the last yearPass
- Package name not close to a popular packagePass
- Remote endpoint uses HTTPSNot checked
- Destructive tools are labelledNot checked
- No hidden instructions to the modelPass
- No critical advisory in the package or its dependenciesNot checked
README
View on GitHubQuilt runs on your machine: one process, no account, no cloud backend, data in ~/.quilt. Generation goes through the channel you pick: your Claude subscription (the claude CLI), an Anthropic, Gemini or OpenAI-compatible API key, or a Claude Code session you already have open.
What it does
- Generate. Describe the app. Quilt plans a 4–6 screen main flow (or the 1–4 screens you ask for), generates each screen as self-contained HTML in the project's design system, lints and screenshots it, and lays it out on the canvas. Ask for up to 4 candidates per screen and adopt one.
- Edit. Select screens and describe the change. In a focused screen,
⌘Epicks any element: change its text, classes or link with zero tokens, or have AI regenerate just that block. - Sketchbook. A full-page board for one-off components and pages outside any project. Describe one, refine it by picking elements, step through versions, then put it into a project as a new screen, over a screen, or in place of one block.
- Canvas. Pan, zoom, drag, align and distribute.
⌘Kjumps to any screen; a minimap and a filterable screen list keep large projects navigable. Double-click a screen to use it live. - Prototype. Links, forms and
data-hrefbuttons move between screens with state kept and a back stack. Overlay screens (sheets, dialogs) open on top of the current one; state variants (empty, error, signed out) share a route. Broken links are flagged and fixed in one click. Export the whole prototype as one offline HTML file. - Design system. A seed colour or an explicit brand palette (light and dark) yields tokens, a
DESIGN.mdand component recipes. Upload assets, save presets, and re-flow every screen when tokens change. - Shared components. Tab bars, app bars and sidebars live on the canvas as components; edit one and every screen using it updates without a model call.
- History. Every generation, edit and agent write is a revision you can roll back to.
- Together. People on your network who open the same project see each other's cursors, selections and views, and can follow one another.
- Settings. Generation channels (keys encrypted at rest), a usage dashboard by day, model, project and task, an optional local record of UI actions and model calls, and a Chinese or English interface.
- MCP, both ways. Your coding agent gets 57 tools and 7 resources at
http://127.0.0.1:3100/mcp. Quilt can also hand a job to a running Claude Code session.
How it works
Browser (React 19 canvas) ──REST / SSE──▶ quilt process (Hono, 127.0.0.1:3100)
◀─iframe────── preview origin (127.0.0.1:3101, read-only HTML)
├─ in-process job queue + worker (LLM, lint, inject, screenshot)
├─ MCP server (Streamable HTTP, same service layer as REST)
├─ chat jobs over the API (Claude Agent SDK subprocess, talks to the same MCP)
└─ agent delivery (hands jobs to a local Claude Code session)
~/.quilt: PGlite database · objects/ · config.env
Screens are plain HTML with Tailwind classes and the project's tokens; stable element ids let an edit target one block. The preview runs on a separate origin, so generated scripts cannot reach Quilt's own storage.
docs/DESIGN.md is the single source of truth: requirements, data model, API contract, state machines and ADRs. docs/TEST.md holds the test cases and the log of every test round.
Quick start
Requirements:
- Node.js 22 or newer, pnpm 11
- Chrome or Edge for screenshots (otherwise run
npx playwright install chromiumonce) - A generation channel: the
claudeCLI logged in (the default,LLM_DRIVER=agent-sdk), an Anthropic or Gemini API key, or an OpenAI-compatible endpoint added in settings
Run the packaged app
pnpm install
pnpm build # builds the web bundle and apps/cli/dist
node apps/cli/bin/quilt.js # or: npx quilt-canvas, once the package is published
The first run creates ~/.quilt (embedded PGlite database, object store, config.env with generated secrets), runs migrations and opens http://127.0.0.1:3100. Run it again with the same home and your projects are there.
Flags: --home <dir>, --port / --preview-port (default 3100 / 3101), --no-open. The default channel is set in ~/.quilt/config.env:
LLM_DRIVER=agent-sdk # agent-sdk (local Claude subscription) | anthropic | gemini
ANTHROPIC_API_KEY=
GEMINI_API_KEY=
Run from source
pnpm install
cp .env.example .env # leave DATABASE_URL empty to use embedded PGlite
docker compose up -d # optional: Postgres on 127.0.0.1:5439 if you set DATABASE_URL
pnpm dev # API + worker + preview on 3100/3101, Vite on 6688
Open http://localhost:6688. Migrations run at API startup; every key in .env.example is documented inline.
Connect your coding agent
claude mcp add --transport http quilt http://127.0.0.1:3100/mcp
The server listens on loopback only, so there is no authentication. Everything the canvas and the sketchbook do is available as a tool; only API keys stay in the settings panel.
Read with get_outline (a compact summary of every screen) before get_screen. Keep writes small: patch_screen for a partial change, create_upload_url plus several append_upload chunks for a screen over ~8 KB, because one very long tool argument can cut a streamed model response short. Writes carry expectedRevisionId and return 409 on a stale base, so two writers cannot overwrite each other.
The other direction: choose "hand to local Claude Code" as the channel in the composer and pick a running session. Quilt delivers the prompt there; the session writes back over the same MCP and closes the job.
- Projects:
quilt.list_projects,create_project,get_project,update_project,delete_project,create_surface,update_surface,delete_surface - Reading:
get_outline,get_screen,get_screenshot,get_revision,list_revisions,list_candidates,get_design_contract,get_app_map,list_assets,list_messages,list_jobs,get_job,get_job_events,list_runners,list_design_presets - Writing screens:
validate_screen,create_screen,update_screen,patch_screen,create_upload_url,append_upload,link_screens,move_screens,edit_element,restore_revision,adopt_candidate,delete_screen - Sketchbook:
get_sketchbook,create_draft,copy_draft,move_drafts - Shared components:
create_component,update_component,delete_component - Design system:
update_design_system,create_design_preset,apply_design_preset,delete_design_preset,create_asset,delete_asset - Model jobs:
generate_screens,edit_screens,regenerate_subtree,edit_component,propose_design_system,export_prototype,get_export,cancel_job,finish_job - Resources:
design-md,tokens,app-map,golden,screen-html,screen-screenshot,attachment
Repository layout
apps/api Hono server: REST, MCP, SSE, preview origin, in-process worker, Drizzle schema + migrations
apps/web Vite + React 19 + Tailwind 4 canvas and sketchbook
apps/cli esbuild bundle of api + core + web → the `quilt-canvas` npm package
packages/core shared: zod schemas, prompt contract, lint rules, runtime injection, export, tokens, outline
tests/unit node:test unit tests for the pure functions in core and the canvas (pnpm test)
tests/e2e Playwright scripts that execute the cases in docs/TEST.md
docs/CHANGELOG.md older change-log rows moved out of DESIGN.md / TEST.md
docs/DESIGN.md design document (requirements, data model, API contract, state machines, ADRs)
docs/TEST.md test cases with REQ traceability and the execution log
CLAUDE.md working discipline for coding agents contributing to this repo
Development
pnpm typecheck # tsc across core / api / web
pnpm test # unit tests (node:test, ~1.5 s, no database or browser)
pnpm build # web bundle + CLI package
pnpm seed # wipe the database DATABASE_URL points at, create two demo projects
pnpm mcp:call <tool> '<json>' # call an MCP tool against the running server
The end-to-end suites in tests/e2e run against an isolated stack (scripts/e2e-stack.sh; scripts/e2e-all.sh runs them in order). They wipe the database they point at, so they refuse to start unless its name ends in _test. LIVE_LLM=0 skips the turns that need a real model; environment details are in docs/TEST.md §3.
Every change goes the same way: update docs/DESIGN.md, then the code, then the affected cases in docs/TEST.md, then run and log a round.
Status
v1.42, local edition: it runs on one machine, and people on the same network can open it together. Mobile and desktop screens, plus free-form drafts in the sketchbook. Deferred, not dropped: multi-user SaaS (login, quotas, remote dispatch). Out of scope: production React code generation, native rendering.
License
Apache-2.0. See LICENSE.
Quilt MCP questions
How do I add Quilt MCP to Claude Code?
Run claude mcp add quilt -- npx -y quilt-canvas in your terminal. Add --scope user to make it available in every project.
How do I add Quilt MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
Does the Quilt MCP server require authentication?
No. The server only listens on loopback, so there is no authentication; API keys stay in the settings panel.
What tools does the Quilt MCP server expose?
It provides 57 tools and 7 resources covering projects, screen reading and writing, sketchbook drafts, shared components, the design system and model jobs.
How do I avoid conflicting writes from two agents?
Writes carry an expectedRevisionId and return 409 when the base revision is stale, so two writers cannot overwrite each other.
How should an agent read screens efficiently?
Call get_outline first for a compact summary of every screen, then get_screen for the screens you actually need.