FAgent
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
FAgent
Not another design tool rebuilt for humans — a design tool built for agents.
FAgent is a design tool made for AI agents. Agents create, read and edit designs through MCP; people watch the result live in a read-only browser viewer. There is no mouse editor, chat or terminal inside the product: the agent is the author, and the viewer is where you review, inspect, preview and share its work.
A Rust backend owns the design model. Every MCP read is one consistent revision, and every write is an atomic, idempotent batch, either JSON structured operations or the compact OCD line DSL, guarded by the revision it was based on. Designs are built from pages, frames and stacks, tokens with named themes, text and paint styles, components and instances, interaction states, links and animations. Projects are stored in SQLite (default) or PostgreSQL. Rendering jobs produce PNG frames and node exports (PNG/SVG) for the agent to check its own work.
Highlights
MCP-first authoring. About twenty tools cover projects, reads, writes, rendering and exports (
tools/listshows their schemas).apply_batchtakes up to 500 ordered operations or OCDsource, withexpectedRevision, a stableidempotencyKey, optional page-scoped guards (pageIds,strict) anddryRun. A stale write fails withREVISION_CONFLICT, the current revision and what changed since (get_changes).Token-efficient reads and writes.
get_outlinewith a depth,find_nodesby name, text, kind, ID or parent, scopedget_subtree/get_design_context(withcompact:truereturning only referenced resources), OCD source instead of verbose JSON, assets imported from the projectinbox/by path instead of base64, andrender_framethat omits the computed scene unless asked.Design-system building blocks. Color, dimension and number tokens with aliases and scoped themes, styles, reusable components with flat instance overrides (
get_design_contextlists each master once), declared interaction states, prototype links and animations. Authored references and resolved values are returned side by side, so code can be written against the tokens rather than raw values.GPU viewer powered by Vello. A dedicated Worker runs one WASM module that computes frame scenes with the same Rust core as the server and paints them on the GPU: WebGPU first, then WebGL2, then
vello_cpu, then Canvas2D, so the canvas is never blank. The main thread only draws a thin overlay for labels and selection.All pages board. One board with every root frame of every page, grouped in tinted page sections with title tabs; click a tab to zoom to that page.
Live updates. The viewer keeps one Server-Sent Events stream per tab; new projects and commits from the agent appear without reloading. Follow agent (off by default) jumps to the project the agent is working on.
Motion preview. Preview opens
/previewfor the selected frame and plays its declaredprops.animations(load, hover and click triggers, infinite loops), interaction states and navigate links in the browser, with Replay and a reduced-motion toggle.Deep links to any element.
/?project=…&page=…&frame=…&node=…opens and highlights a node, including virtual instance children. Copy link (orCmd/Ctrl+C) copies it, and the MCP instructions teach agents to resolve such a link withfind_nodesandget_design_contextinstead of guessing.Exports. Export PNG or SVG from the Inspector or the context menu, or call
export_nodeswith scale/width/height settings (or the node'sexportSettings). SVG keeps live text and embeds the exact font bytes.Fonts. The Fonts dialog lists, imports (TTF, OTF, WOFF2) and downloads project fonts. Fonts are stored with the project and never installed on the operating system.
Public read-only viewer. An opt-in second listener for sharing through Tailscale Funnel serves only projects marked
public, with an optional shared password, device sessions managed through MCP, and live updates off unless enabled.Backups. The storage layer exports, imports and restores self-contained project bundles with a checksummed manifest; the native PostgreSQL deployment has its own backup tooling.
Related MCP server: ggui
Performance
Every number below comes from a benchmark recorded in the repository; none was rerun for this page. They are single runs on one machine, so read them as orders of magnitude, not guarantees.
Backend, large project. The Task24 harness copies a real 6,711-node project 1× and 30× (30× = 201,330 authored / 599,400 expanded nodes, 570 pages) and times MCP reads and a one-text-node commit. It ran on an Apple M5 (10 cores, 24 GiB) with a release build. PostgreSQL 16 ran in a container limited to 2 CPUs / 2 GiB. Values are median / p95 ms. "Before" is the original baseline; "now" is the rerun after the incremental validation and page-scoped reads of Task25.
Operation | Project | SQLite before → now | PostgreSQL before → now |
| 1× (6.7k nodes) | 788.8 / 876.2 → 11.3 / 11.5 | 765 / 787.2 → 3.8 / 4.0 |
| 30× (201k nodes) | 42,608.6 / 46,357.8 → 212.4 / 216.4 | 30,426.1 / 34,675.8 → 403.1 / 410.2 |
| 30× | 1,824 / 2,529.8 → 249.2 / 268.3 | 1,233 / 1,280.8 → 417.8 / 467.8 |
Commit, strict ( | 1× | 404.8 / 422 → 63.5 / 65.7 | 377.2 / 389.8 → 98.2 / 129 |
Commit, strict | 30× | 12,723.7 / 13,348.2 → 2,030.6 / 3,547.4 | 12,639 / 13,294.1 → 2,444.4 / 2,789.7 |
Commit, page-scoped ( | 30× | 38,871.9 / 40,419.7 → 1,880.9 / 3,403 | 34,121.9 / 55,458.4 → 2,269.4 / 2,646.1 |
Storage cold snapshot load | 30× | 225.5 / 256.8 | 356.2 / 421.9 |
The 30× responses stay the same size as at 1× (outline 72 KB, context 92 KB): the work grows with the project, but the answer does not. Write latency at 30× is still above the ~1.5 s target recorded in the report; validation dominates it.
Node-memory (experimental, off by default). Task28
keeps hot projects in RAM (crates/node-memory), with indexes updated per operation and the
database still the source of truth. It sits behind three flags, FAGENT_NODE_MEMORY_SHADOW,
FAGENT_NODE_MEMORY_READS and FAGENT_NODE_MEMORY_WRITES. Each defaults to off; set one to on
to enable it (strict is for tests, and WRITES=on also turns on reads and the mirror). The figures below were measured on a
generated 200k-node fixture with PostgreSQL and a release build; the source does not record the
hardware. This fixture differs from the Task24 project, so do not compare it with the table
above.
Measurement (PostgreSQL, 200k-node fixture) | Flag off | Flag on |
| 156 ms cached; 207 ms right after a write | 1.5 ms warm; 2.0 ms right after a write |
Page-scoped commit, median of 30 ( | 636 ms (load 200, persist 34) | 468 ms (load 29, persist 3) |
Same commit, real project of 7,025 nodes | 28.5 ms | 22.5 ms |
Shadow mirror cost per commit ( | – | 114 µs (17–26 µs on real projects); first load 76 ms |
In-memory operations on the 200k fixture take well under a millisecond: a props update takes 584 ns, and a begin + commit takes 542 ns. Memory use is about 1.3 KB of RAM per authored node. Later node-memory stages (persistent reader indexes, delta validation, HOT reader cleanup) have been implemented, but their benchmarks are deferred. See the I3b, I4 and I5 reports and the base verification.
Viewer. These numbers come from an Apple M3 Pro with a production build (details). On a board of 12 frames and 4,945 nodes, the Vello engine reaches "Scene rN" in 1.8–1.9 s, against 2.8–3.6 s for Canvas2D in the same run. Panning at Fit draws in 13.3 / 13.8 ms (p50 / p95). No main-thread task exceeded 50 ms while panning or zooming.
Architecture
agent (MCP) / browser ──► fagent-server HTTP API · MCP · SSE · serves web/dist and the
│ hash-named, immutable /engine-wasm module
├─► fagent-storage SQLite | PostgreSQL (+ node-memory behind a flag)
└─► export jobs: queue → admission → runner, backend fixed at build time
├─ vello: in process fagent-layout → fagent-text →
│ fagent-paint-vello (vello_cpu) → PNG via paint-core
└─ chromium: Node worker → layout-step + Playwright Chromium
(renderer/ Canvas2D) → PNG
browser viewer (web/) ──► engine-wasm in a Worker: scene-wasm → fagent-paint-vello →
vello_gpu WebGPU → WebGL2 → vello_cpu → Canvas2D fallbackCrate | Role |
| HTTP/MCP/SSE, jobs (render, export), viewer static files, public viewer |
| SQLite or PostgreSQL storage, revisions, assets and fonts |
| In-memory node indexes ( |
| Authored models, validation and scene input preparation |
| Taffy layout with text measurement (also the chromium worker's |
| Font loading, HarfRust shaping and glyph outlines shared by measure and paint |
| Backend-neutral paint contract: wire scene, validation, strict resources, image decode/ICC, PNG encode |
| scene-3 encoded for Vello: |
| Snapshot → resolved scene in the browser |
| Viewer engine Worker: scene-wasm compute + paint-vello + |
The server's vello export and the viewer share fagent-layout, fagent-text and
fagent-paint-vello; the former tiny-skia painter (crates/render) was removed. Details:
docs/VIEWER.md, docs/SERVER.md,
Task 34.
Local setup
The verified development environment is Rust/Cargo 1.99.1, Node 24.21.0, npm 11.19.0 and Playwright Chromium 156.0.8078.4. Dependencies are pinned in the lockfiles. From this repository:
npm ci
npm --prefix web ci
export PLAYWRIGHT_BROWSERS_PATH="$PWD/.runtime/browsers"
npx playwright install chromiumThe first installation needs registry/network access. Build and launch the whole app with either profile:
Profile | Build the renderer, Rust server/layout and viewer | Launch the existing build |
Debug |
|
|
Release (optimized Rust binaries) |
|
|
Both launch commands run the Rust server and serve the compiled web/dist viewer. They reuse existing artifacts without rebuilding. A missing artifact reports the matching build command. The build commands require the installed root/web Node dependencies and Rust toolchain; they never install dependencies or Chromium. With Cargo dependencies cached, append -- --offline to either build command. The viewer build may report a JavaScript chunk-size warning.
The browser WASM modules are built separately (Docker builds them automatically). They need the
wasm32-unknown-unknown target and wasm-bindgen 0.2.129:
npm run build:scene-wasm # frame scene computation in a browser Worker (Canvas2D path)
npm run build:engine-wasm # Vello engine: scene computation and GPU paintingWithout the engine module the viewer falls back to Canvas2D with a notice. See browser scene build, parity and timings and the Vello engine.
For example, build and run the optimized app with an isolated data root and a free port:
npm run build:release
npm start -- --port 0 --data-root /path/to/separate-dataBy default, open the local viewer; with --port 0, use the URL printed at startup. Starting the server creates no demo project. The backend launches the Node/Chromium rendering worker when needed and listens only on loopback. Stop it with Ctrl-C: open event streams are told to end, and a second Ctrl-C (or three seconds) leaves immediately. Keep the repository's built renderer, layout binary, worker and browser installation available while running.
CARGO_TARGET_DIR selects the Cargo output directory for both building and launching; set it consistently for both commands. Relative values resolve from the repository root. Launchers select the server and layout worker from the same debug or release directory and pass the layout binary through FAGENT_LAYOUT_BIN. They default PLAYWRIGHT_BROWSERS_PATH to the repository's .runtime/browsers; an explicit environment value wins. The viewer and renderer bundles are shared by both profiles, so rebuilding either profile refreshes these bundles.
PORT selects the local listener (default 3847), and --port NUMBER takes precedence. Both accept 0 to bind an available port and print it at startup.
Contributors: enable the public-content hook with git config core.hooksPath .githooks and install gitleaks (brew install gitleaks) so commits are also scanned for secrets.
For optional frontend hot reload, keep the backend running and run npm --prefix web run dev separately. Its /api proxy defaults to port 3847; set FAGENT_API_URL for another backend URL. See viewer behavior and the HTTP contract.
Viewer and render backends
The viewer paints with the Vello engine by default (WebGPU, then WebGL2, vello_cpu, Canvas2D);
the status bar shows the active backend. ?renderer=canvas2d selects the Canvas2D painter, and
?scene=server computes scenes on the server (Canvas2D only). With Canvas2D, browser scene
failures fall back to the server. FAGENT_VIEWER_OVERSCAN (server environment, percent per side,
0–50, default 0 = off) makes the Vello engine draw that much beyond each viewport edge, so a pan
during a long frame computation slides in drawn pixels instead of a blank strip; an invalid value
stops startup. See Overscan.
PNG rendering and exports run on the server with one of two render backends. chromium: a Node
worker drives headless Chromium with the shared Canvas2D renderer. vello: the server computes
in process and paints with vello_cpu, the viewer's encoder, without Node, Chromium or
layout-step (pixels differ slightly from Chrome). The default is chosen at build time with
FAGENT_RENDER_BACKEND=chromium|vello (default chromium), read by npm run build,
npm run build:release, scripts/native/build-release.sh and the Docker build:
npm run build # chromium: also renderer bundle + layout-step
FAGENT_RENDER_BACKEND=vello npm run build:release # vello: no renderer bundle or layout-stepA vello build needs no Node or Chromium to run (Node still builds the viewer).
RENDER_BACKEND or --render-backend overrides the default at startup; asking a vello build
for chromium without its worker runtime fails at startup. The native release on this Mac uses
vello (see Native runtime). Details:
render backends and
Task 34.
Export backends: Chromium vs Vello
Numbers from the Task 34 measurements (PURE-RUST-EXPORT.md § Task 34): a 12-frame board (4 944 nodes) through real server jobs, on a moderately loaded machine, so they compare the two backends rather than set a baseline.
|
| |
Runtime | One binary + | Node, Playwright Chromium, |
Peak RAM (server process tree) | ~324 MiB | ~1.4 GiB (1 393 MiB) |
Server start | ~102 ms | ~303 ms |
Board, cold (p50) | ~1 972 ms | ~2 501 ms |
Frame, warm (p50 / p95) | ~125 / 162 ms | ~132 / 151 ms |
Pixels match | What the FAgent viewer draws: the same layout → text → | What a Chromium browser draws (Canvas2D in headless Chromium) |
Two renderers, one design. The backends differ the way two browser engines do (Firefox's WebRender and Chromium's Skia drawing the same page): geometry, colour, layout and text positions are the same; the differences are at the level of anti-aliasing, text rasterization and numeric precision. Measured against Chromium, 44 of 75 non-text parity cases stay under the strict gate (< 0.5% of pixels differing by more than 8/255); the others differ in low-alpha gradient and shadow tails, stroke edges at scale 1 and image sampling (0.5–1.8% of pixels on white). Text differs in up to ~6.6% of pixels (Vello outlines vs CoreText glyphs), with identical line positions and geometry.
Choosing:
velloexports what the FAgent viewer shows, with no Node or Chromium at runtime, about a quarter of the memory and a faster cold start. The raster is single-threaded and CPU-only (a GPU export, Task 34 phase 5, was not pursued: raster is not the bottleneck); the warm p95 was slightly above Chromium's in this run.chromiumexports what a Chromium browser draws, so it is the closer reference when an agent's implemented HTML/CSS is scored against the design by raw pixel diff (for example "> 90% match"), where a 1–2% difference (text up to ~6.6%) can count. It needs the Node worker, Playwright Chromium and their artifacts at runtime. Element-level comparison (Task 23) or a pixel diff that ignores anti-aliasing is less sensitive to the renderer either way.
RENDER_BACKEND=chromium|vello overrides a build's default at startup, provided that build
ships the runtime the backend needs.
Storage
DATABASE_PROVIDER accepts sqlite (default) or postgresql. SQLite uses ~/.fagent by default. Set FAGENT_DATA_ROOT or pass --data-root DIR to override it. Each SQLite project uses <data-root>/<slug>/db.sql (SQLite binary) and assets/. Only create_project creates a project. Use a separate temporary data root for SQLite experiments and tests.
For PostgreSQL, set DATABASE_URL to your connection string in the environment, then launch the built app:
DATABASE_PROVIDER=postgresql PORT=3850 npm startOptional PostgreSQL limits (positive integers; unset keeps the default; an invalid value stops startup and names the variable):
Variable | Default | Range |
| 4 connections | 1–32 |
| 3000 | 1–2147483647 ms |
| 15000 | 1–2147483647 ms |
| 3000 | 1–2147483647 ms |
| 30000 (pool wait per operation; also idle-in-transaction and TCP user timeouts) | 1–2147483647 ms |
FAGENT_DATABASE_SCHEMA selects the schema that holds the runtime tables (default fagent_runtime_v1, for example public); it must be 1–63 lowercase letters, digits or _, starting with a letter or _.
npm run dev accepts the same environment variables. PostgreSQL uses an in-process snapshot cache with a one-hour TTL; it reads only import_asset/import_assets and apply_batch_file files from <data-root>/<slug>/inbox and stores nothing in the data root. Changing providers selects a different store. SQLite projects stay in the data root and require a separate migration to appear in PostgreSQL. See the PostgreSQL adapter for database permissions and transport details, and backup/restore for project bundles.
Connect an agent
Configure an MCP client with Streamable HTTP and URL http://127.0.0.1:3847/mcp (adjust the port if needed). This is an HTTP endpoint, not a stdio command. A minimal connection entry is:
{ "url": "http://127.0.0.1:3847/mcp" }The surrounding configuration format depends on the client. The client initializes a session and retains the negotiated MCP session/protocol headers. The checked transport negotiates protocol 2025-11-25.
Use list_projects/create_project, then get_outline before scoped get_subtree or get_design_context. Resource metadata is available through list_tokens, list_styles, list_assets and list_fonts. import_asset takes one asset (10 MiB) from a file in the project's inbox/, bounded base64, or another project's asset or font (sourceProjectId with assetId or fontId); it never fetches URLs. import_assets takes 1–50 such items (64 MiB in total) and commits them as one revision. apply_batch_file applies a file from the inbox: .ocd OCD source or a JSON operation array (recommended for large or iterative batches: dry-run, fix the reported line, apply). apply_batch takes a projectId, expectedRevision, stable idempotencyKey and ordered operations or OCD source (read skill://fagent/ocd.md through MCP). Reuse the exact body/key after a lost response; read back after a revision conflict.
Create a page, then a frame, then its descendants. Text must declare a valid font (the bundled font is font_bundled), size and line height, or obtain them from a valid text style. render_frame returns a job; poll it by jobId, inspect its exact revision/provenance and obtain the PNG through imageUrl. The response omits the computed scene unless you pass includeScene: true; inspect_layout reads the bounds and text lines for that job's scene key. export_nodes returns PNG/SVG files of up to eight nodes. Available tools expose their schemas through tools/list.
To implement an existing design in code rather than author one, read get_outline for the frame,
then get_design_context for that frameId. Nodes carry authored props beside resolvedProps:
the authored side holds the token and style references the design was built from, the resolved
side what they evaluate to for one theme, so code written against the reference survives a theme
change. Build the structure the design declares — a container's layout mode is row, column
or free, with padding and gap — instead of deriving it from measured bounds; those bounds
and the wrapped text lines belong to one viewport and are there to check the result. The design
can declare named token themes, flat visual states, links and animations.
Context can resolve declared states, render_frame previews a selected state, and HTML
preview plays declared links and motion. These declarations do not supply application data,
screen transitions or arbitrary layout/font variants.
Read the generated props resource and
fagent://capabilities through MCP resources/read before approximating an
unsupported property. Capabilities distinguish authored keys, Canvas/PNG, HTML preview
and SVG; cache by fingerprint/version, and inspect runtime job readiness separately.
Author one full semantic string per paragraph/label, preserving spaces and intentional
hard breaks. Read that authored source when implementing; measured line/character positions
are comparison evidence at one viewport. Intentional lettering, wordmarks and per-letter
motion remain valid: record their intent with a node note. Text diagnostics are advisory,
scoped and bounded; they never merge or rewrite layers automatically.
Share a read-only viewer
To share the viewer through Tailscale Funnel, use the separate, opt-in
public read-only listener.
It exposes assets, fonts, downloads and exports only for projects
marked public. Live updates there are off by default (a reload shows newer
changes); set FAGENT_PUBLIC_LIVE_UPDATES=on to enable them. Projects start private. Ask your agent to call
update_project with {"projectId":"<id>","privacy_status":"public"} to share
a project, or pass "private" to withdraw it. Set a shared viewer password through the local MCP tool
set_public_viewer_password to require sign-in, and use
list_public_viewer_sessions and revoke_public_viewer_session to manage
devices. MCP, project creation and font import stay on the local listener.
Funnel must target the public port (3848 by default, 3858 with PostgreSQL
Compose). See password and proxy setup.
Docker
The default (chromium) image bundles the release server, layout-step, worker, renderer, viewer and Playwright's Chromium headless shell (Rust 1.99.1 and Node 24.21.0 on Debian trixie); no local toolchain is needed:
docker build -t fagent:local .
docker compose up -d
node docker/smoke.mjs http://127.0.0.1:3847 # optional: creates a project smoke-<time>The viewer is at http://127.0.0.1:3847 and MCP at http://127.0.0.1:3847/mcp. Projects live in the named volume fagent-data mounted at /data; the container never sees ~/.fagent. To keep them in a host directory instead, replace fagent-data:/data in compose.yaml with a bind mount such as ./fagent-data:/data, writable by uid 1000 (the node user of the chromium image, fagent of the vello image). docker compose stop sends SIGINT, which shuts the server down gracefully.
Inside the container the server listens on 0.0.0.0 (--host 0.0.0.0), and compose.yaml publishes it on 127.0.0.1 only. Keep it that way: the API has no authentication, and the loopback Host check stops browsers, not other machines. FAGENT_PORT=3850 docker compose up -d moves the host and container port together, so imageUrl and the Origin check match the address you use. With plain docker run, use --init -p 127.0.0.1:3847:3847 -v fagent-data:/data --shm-size 512m. Do not run the native server and the container on the same data root at the same time: the data-root lock is not guaranteed to work across a bind mount.
The default Compose file runs SQLite. Local PostgreSQL in Docker Compose runs the app and PostgreSQL in two containers, with a separate data volume and the optional read-only viewer.
The image's render backend is a build argument: FAGENT_RENDER_BACKEND=vello docker compose build
(or docker build --build-arg FAGENT_RENDER_BACKEND=vello) makes an image without Node, Playwright
or Chromium (a debian:trixie-slim runtime with the server and viewer only); the default build is
chromium. Compose passes RENDER_BACKEND into the container only when it is set in the env
file or shell, otherwise the image's default applies. The public-viewer overlay preserves this
choice. Recreate the app container after changing it; the browser viewer is unaffected by this
setting. The Compose healthchecks use bash, so they work with either image.
For the isolated local PostgreSQL deployment on OrbStack, see Local Kubernetes. It builds a separate image, keeps database data in a PVC and exposes the viewer/MCP only through loopback port-forward on port 3857. The opt-in Kubernetes public viewer adds a separate read-only listener on loopback 3858 for later user-managed Funnel.
Verification
npm run test:e2eThis builds the required artifacts using cached Cargo dependencies, starts the production Rust server on a random loopback port with a temporary data root, and drives MCP plus Chromium. It terminates the test processes and removes the temporary project afterward. A sandbox must permit loopback listeners and Chromium. The shorter node spikes/e2e/run.mjs reuses existing builds.
The live acceptance run verifies MCP creation/import, SQLite structure, typed authored/resolved readback, exact scene and PNG provenance, viewer/PNG pixel equality, token updates through production SSE, narrow viewport wrapping, invalid-batch rollback, idempotent retry, and persistence through backend restart and browser reload. It also checks that viewer API traffic uses GET only. See the E2E protocol and limitations. Each run writes its machine-readable evidence, PNG and viewer screenshot to artifacts/e2e/ (not versioned).
Targeted module checks remain separate:
npm run check:renderer
npm run test:pipeline
npm --prefix web run typecheck
npm --prefix web test
cargo test -p fagent-storage --offline --features fault-injection -- --test-threads=2
cargo test -p fagent-server --offline -- --test-threads=2The live E2E covers one small project on the recorded Chromium runtime; it does not establish cross-platform pixel identity or every failure/recovery case. Milestone acceptance is tracked separately in docs/ACCEPTANCE.md.
Documentation
Topic | Document |
Product requirements and acceptance criteria | |
MCP tools, HTTP API, jobs, SSE, public viewer | |
Viewer ↔ HTTP API contract and data types | |
Browser viewer, Vello engine, All pages, motion preview | |
Large-project benchmarks and node-memory | |
Tokens, aliases and themes | |
Components and instances | |
Fonts | |
Project bundles, backup and restore | |
Native macOS runtime and PostgreSQL backups | |
Storage benchmark |
License
Licensed under either of Apache License, Version 2.0 or MIT license at your option.
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
Bundled fonts keep their own licenses: Noto Sans (renderer/fonts/OFL.txt) and the Lato test fixtures (fixtures/fonts/Lato-OFL.txt) are under the SIL Open Font License 1.1.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
Design canvas for agents: create, edit, render and export Figma-shaped designs over MCP.
Your AI agent designs editable, clickable UI prototypes on a live canvas.
Deploy AI-generated HTML/CSS/JS to instant public HTTPS URLs from any MCP-compatible agent.
Live, editable canvas for AI agents — author graphs via MCP, then watch and reroute runs live.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceMCP server that enables AI coding agents to read and write to a local-first HTML/CSS design canvas, bridging visual design and code generation.1MIT
- AlicenseNot gradedqualityBmaintenanceEnables AI agents to generate and serve ephemeral, interactive user interfaces over MCP through natural language descriptions.44Apache 2.0
- AlicenseNot gradedqualityBmaintenanceEnables AI agents to create and manage consistent multi-screen UI designs through a token-efficient MCP interface, with design system tokens, components, flows, and visual review.293 npm2AGPL 3.0
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to build and edit real HTML/CSS designs on a live canvas through 35 MCP tools, letting them inspect screenshots, computed styles and layout, then export production-ready React or Tailwind code. Humans can refine the same layers visually in a macOS editor.6,734 npmMIT