keyline MCP server

keyline-mcp

An AI-native design engine: agents design, keyline renders. No Chrome, no browser. An AI agent (Claude Code, Cursor, Cline or any MCP client) describes a design once as a small JSON scene. A Rust renderer built on Skia turns it into PNG, JPEG, WebP, vector PDF, animated PNG, GIF, MP4 or WebM at every size you need: portrait post, landscape banner and skyscraper ad from one master layout. Output is deterministic: no model generates pixels, so the same scene always renders the same design. There's no browser anywhere in the pipeline: no headless Chrome, Puppeteer or Playwright to install, run or keep patched on the server, just one native binary.

Think of it as Figma or Canva for AI agents: a design tool whose only user is a language model, for social posts, display ads, flyers, banners and other marketing images.

Status: early development. The scene format and the tools still change.

One scene, three sizes: a square post, a wide banner and a story, each laid out by the engine from a single design (the scene).

The same design with motion, rendered as an animated PNG with no browser and no video tool (the scene).

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<br/>scale → constraints"]
    L --> C["Checks<br/>defects · advisories · facts"]
    C -- "ok, or what to fix" --> A
    L --> R["Skia renderer<br/>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

Shortened. The full README is on GitHub.