keyline

keyline-mcp

[keyline.dev](https://keyline.dev): examples, the benchmark, and setup for every client.

Design engine for AI agents: Canva for your agent. keyline is a free MCP server for Claude Code, Claude Desktop, Cursor, Codex, Gemini CLI and any MCP client. Your agent describes a social post, ad or banner once, as a small JSON scene; keyline renders it as images and video at every size, with real text in your fonts and colors, the same every run.

No browser, and fewer tokens. No headless Chrome, Puppeteer or Playwright: one native Rust binary on Skia. Every edit replies with what's wrong at each size, so the agent fixes the design from measurements instead of screenshots: 2× fewer tokens than an agent driving headless Chrome, and 6× fewer than Playwright MCP (benchmark).

One prompt, five sizes: the layout adapts from a 4:5 post to a 728×90 leaderboard, and keyline's checks catch what doesn't fit before anything renders.

More campaigns, with motion, on keyline.dev . Every image there, and the one above, was made with keyline.

---

Why

Most designs people ship today (sale posts, event flyers, ad sets) are made in tools like Canva or Adobe Express. Those tools are built for a person with a mouse, and none is a good backend for an agent:

• Canva and Adobe Express keep their scene graph private: you can export pixels, not the design.
• Browser-based renderers such as Polotno need headless Chrome on the server.

keyline-mcp is the missing piece: an agent-first design tool, with a design format and renderer built from the ground up for a language model to author, check and export, cheaply and reproducibly. The design stays structured data (a typed layer tree with layout, tokens, styles and components), not pixels, so an agent edits it precisely instead of regenerating an image.

How it works

flowchart LR

A[Agent] -- "layer_add / layer_update" --> S[(Scene JSON)] S --> L["Layout per size scale → constraints"] L --> C["Checks defects · advisories · facts"] C -- "ok, or what to fix" --> A L --> R["Skia renderer GPU, CPU fallback"] R --> P["PNG, JPEG, WebP, PDF, animated PNG, GIF, MP4 or WebM per size"]

1. One master layout. A design is written once at a master size and lists its target sizes.
2. Layouts that adapt. Rows, columns, grids and design-tool constraints lay the design out again at every size, with no constraint solver; any layer can change for one size or aspect class.
3. Checks, not previews. Every edit's reply says what's wrong at each size, with the measurement that fixes it.
4. GPU by default, deterministic when it matters. Renders run on the GPU and fall back to the CPU, whose output is exactly repeatable.

Start here: docs/concepts.md explains the model; docs/scene.md is the scene format and docs/tools.md the tools and configuration.

LLM-first, and LLM-only

There's no GUI, and no plan for one. Every design decision is judged by one question: *how many tokens does the agent spend to get a correct image?* We measure that with a real model (Claude, through Claude Code) building a real multi-section ad.

• Few, batched tools: six tools, not one per property; one call can build a whole ad.
• Short replies: edits return the changed ids, a version, and ok or the problems, never the scene.
• Defaults left out: a typical layer is 4–6 fields.
• Standard names: CSS names and values wherever CSS has the concept (flexbox and grid fields on frames, fontWeight, borderRadius, rgba() colors), so the model writes a scene right the first time. The layout itself is keyline's own, documented, not browser-exact.
• Semantic targets: layers are addressed by role, so the agent never reads the scene to find an id.
• Verification without pixels: defects to fix, advisories to judge and facts to weigh, each with the measurement that fixes it (how).
• Names, not inventions: icons, shapes, styles, tokens and components by name. Icons alone took rebuilding a real flyer from $0.22–0.62 to $0.15–0.19 per run.
• Measured, not guessed: every change is judged on several real-model runs, kept in keyline-bench.
• Taste stays with the model: the server flags only objective defects and reports the rest as facts.

Features

• Layers: text, image (PNG, JPEG, SVG), video, icon, rect, ellipse (and arcs and rings), polygon (and stars), path (SVG path data or a named shape), line, frame (nesting, clipping, stacks, grids), spacer, firstFit, and use for components
• Layout: stacks (CSS flexbox: rows and columns with gap, padding, alignment, justification and wrapping; fill, flexGrow and priorities), grids (CSS grid: tracks, named areas, spans), hug/fill/percentage sizes with min/max and aspect ratio, direction lists and firstFit that pick what fits, constraints, placement at nine spots, a scale factor per size, per-size and per-aspect changes (media), size presets for common social and ad formats, and safe areas a platform covers
• Text: fit, wrap or one line; inline markup ( , , , style names as tags); weights, italics, letter spacing, line height, case; balanced or pretty wrapping; highlights behind words; underline and strike; text on a curve; dot leaders; text filled with an image, pattern or gradient; outlines; text that knocks out its frame. Fonts work like CSS web fonts: name any Google Fonts family and the server downloads it on first use and caches it (tracked in fonts/index.json); Inter is bundled, and you can add your own font files
• Paint: stacked fills (solid, linear/radial/conic gradients, images, patterns, film grain), strokes (inside, center or outside, per side, dashed, with arrowheads, hand-drawn), shadows (outer and inner, following a cutout's or text's shape), blur and backdrop blur, masks (gradient, shape, path, another layer or an image), torn edges, 16 blend modes, corner radius, rotation, skew, flips
• Images: fill, fit, crop or tile, with a focus point that stays in view; adjustments (brightness, contrast, saturation, grayscale, sepia, hue, duotone, tint, halftone)
• Icons: about 5,000 built in, by name: Lucide outline icons and Font Awesome Free solid, regular and brand icons, in any color
• Reuse: named styles on any layer, tokens ({{brand}}, in any field or sentence) that update every field using them, components placed once or once per data row, and templates: a scene file loaded by URL or path with its variables set, rendered once per row of values
• Motion: GSAP-style animation: enter and exit effects (fade, fade-up, pop, zoom, blur-in), keyframes on opacity, scale, rotation, offset, skew, blur and color with GSAP's eases, random() starts, staggered children, text split into letters or words that move on their own, strokes that draw themselves, and numbers that count
• Video: video clips as layers, trimmed, slowed or looped, with titles and graphics over them; shots that play in turn, joined by cuts, fades, slides, pushes, wipes or zooms; each clip's own sound carried into the video, mixed with a soundtrack
• Assets: stored under content hashes. URLs are fetched only over http(s), and private and local addresses are refused.
• Output: PNG, JPEG, WebP, vector PDF, animated PNG, animated GIF, MP4 or WebM per size, a still of any moment, with a file-size cap for ad networks, plus an optional contact-sheet preview; rendered on the GPU when available

Quick start

Claude Code (macOS or Linux): the plugin downloads keyline and checks it against the release's SHA256SUMS, or uses keyline-mcp from your PATH.

/plugin marketplace add keyline-dev/keyline

/plugin install keyline@keyline

Claude Desktop (Mac with Apple silicon, or Windows): download keyline-mcp- .mcpb from the latest release and double-click it. Designs and their renders go in ~/keyline, a folder per design, where you can also put the images and logos Claude should use. To work in folders of your own instead, open Settings → Extensions → keyline → Configure, add them, and click Save.

Other clients: install, then add

Every release has a SHA256SUMS file and build attestations: gh attestation verify --repo keyline-dev/keyline. Then add keyline to your client. The command is keyline-mcp; if the client can't find it, give its full path (which keyline-mcp).

Codex (ChatGPT)

Codex is OpenAI's coding agent, included in ChatGPT plans. Its app, CLI and IDE extension share one setting:

codex mcp add keyline -- keyline-mcp

ChatGPT itself, like grok.com and the xAI API, connects only to remote servers, so it can't start keyline, which runs on your machine.

Other clients

Any client that starts local (stdio) MCP servers works, Cursor, VS Code and Gemini CLI included. Add a server named keyline whose command is keyline-mcp, in the client's MCP settings or with its mcp add command. Most clients take this JSON: