CoDesign
OfficialCoDesign is an MCP server that gives you a full design engine to create, edit, preview, and export professional designs with an agent.
Create and edit designs by running JavaScript against the live CE.SDK CreativeEngine, with every change saved as a revision.
Preview pages or specific blocks as images to check your work visually.
Export designs as PDF, PDF/X, PNG, JPEG, WebP, SVG, HTML, or editable
.imglyfiles.Import InDesign, Photoshop, PowerPoint, PDF, image, SVG, and CoDesign files as new designs.
Manage workspace history with revision listing, history walking, inspection of past code, renaming, and change detection.
Open designs in a browser editor so a human can view and edit them; their saves become new revisions.
Find, add, and generate assets — search built-in asset sources, add local images/fonts, and generate images via IMG.LY's AI gateway.
Load skills for guidance on design workflow, API signatures, brand application, creation, formats, localization, resizing, judging, and onboarding.
Register checklists and scorecards to verify deliverables and quality before export.
Sign in / out with an IMG.LY account for AI generation and other account-gated features, and inspect server diagnostics.
Allows creating and editing fully editable Instagram carousel designs, including multi-panel posts, with export to print-ready PDFs and images.
CoDesign
The design layer for the agent era.
Create posters, social posts, videos and print layouts from a prompt, then change any part of them yourself. CoDesign gives you a professional design engine. Every headline, image, shape and clip stays its own layer, so you can swap a font or move a logo without starting over.
Start from scratch or from files you already have. InDesign, Photoshop, PowerPoint and PDF files open with their layers intact. Then resize one design for every social format, translate it with the layout reflowing to fit (Arabic and other right-to-left scripts included), apply your brand colors and fonts, or check it against your guidelines.
Every design opens in a built-in editor when you want to fix something by hand. Export print-ready PDFs with CMYK color and bleed, Photoshop and InDesign files your team can keep working on, or video for social.
Built by IMG.LY on the IMG.LY design engine. Runs on your computer. No account needed to start.
CoDesign ships as an MCP server (plus a plugin for Claude Code, Codex, Copilot
CLI, Antigravity and Cursor) that hands your agent IMG.LY's CE.SDK CreativeEngine — the
same production engine behind IMG.LY's commercial SDKs. The plugin runs the launcher it carries (what it runs); every direct recipe below spawns the published npm package
@imgly/codesign-mcp over stdio; no separate install step — npx fetches it on first
use.
Use cases
A social team turns one campaign into every format, from Instagram posts to short videos.
An agency opens an old InDesign file, rebrands it, and exports it back as .idml.
A global brand translates print ads and video ads without breaking the layout.
A designer generates a first draft, then moves and restyles layers by hand in the visual editor.
A brand manager checks assets against guidelines before they go out.
Related MCP server: Photoshop MCP Server
Formats
Import: InDesign (.idml), Photoshop (.psd), PowerPoint (.pptx), PDF, images (PNG, JPEG, GIF, WebP, SVG) and CoDesign (.imgly) files.
Export: PDF and print-ready PDF/X, PNG, JPEG, WebP, SVG, HTML, InDesign (.idml), Photoshop (.psd), MP4 video, WAV and M4A audio, and CoDesign (.imgly). Video and audio export need the native engine; Windows runs the WASM engine, which has no video.
What you can make
Ask your agent, in plain language:
Resize for every channel — "Take this Instagram post and make the Story, LinkedIn and X versions."
Make an image editable (needs the free IMG.LY sign-in) — "Split this flat product photo into layers, put the product on our brand background and make it editable."
Restyle an existing PDF — "Import this datasheet.pdf as an editable design, restyle it with our brand kit, and export A4 and web versions."
Generate many from a CSV — "One speaker card per row in speakers.csv, same template, all editable."
Prepare for print — "Turn this flyer into an A4 print PDF with 3 mm bleed and CMYK."
Update an existing design — "Open last year's flyer.psd, swap the date and venue, export again."
Localize a design — "Translate this poster into German and re-fit the layout so nothing overflows."
Make a short video (generated music and voiceover need the free IMG.LY sign-in) — "Turn this poster into a 15-second vertical reel: animate the headline in, cut between the three product shots, and put a music bed and a voiceover under it."
Create a launch graphic — "Make the v2.0 launch graphic with our logo and brand colors, in X, LinkedIn and OG-image sizes."
Create App Store graphics — "Make the App Store screenshots and the Play Store feature graphic from these five screen captures, on-brand, all sizes."
How it works
Three layers, one product:
The plugin — installs the MCP server and connects it to your agent. This is the piece you install.
The MCP server (
@imgly/codesign-mcp) — exposes the design tools (edit,preview,export,list,history, …) over MCP, driven by tool calls from any agent host, and serves the skills and design rules your agent draws on to design well (brand, localize, resize, and quality-check its own output), always matching the server's version.The CE.SDK CreativeEngine — IMG.LY's real, headless design engine that does the actual layout, rendering, and export.
Licensing
This repository — the plugin, marketplace manifests and documentation — is
released under the MIT License.
The CoDesign engine itself, distributed as the npm package @imgly/codesign-mcp, is
proprietary software from IMG.LY and free to use locally. The full terms ship
inside the package as LICENSE.md. The launcher in plugins/codesign/runtime/ is not under the MIT License either: its NOTICE names its licences.
Why a real engine matters
Every other design agent draws on a web canvas — a quick fix that breaks on the hard problems. CoDesign commands a production engine matured over years across print, video, and social:
True print & color fidelity — CMYK, bleed, and ICC profiles, not just RGB screen output.
Deterministic output — renders identically everywhere, independent of browser or config.
Native performance — a purpose-built engine that stays fast at scale and under heavy assets.
Full compatibility — imports InDesign, PSD, PowerPoint (PPTX) and PDF; exports print-ready PDF, image, video, InDesign, PSD and HTML.
What the plugin runs
A local MCP server. Claude Code starts
runtime/codesign mcp; Codex, Copilot CLI, Antigravity and Cursor (untested) startnode runtime/codesign-shim.mjs mcpin the plugin folder. Both run over stdio. IMG.LY's CE.SDK engine imports, renders and exports on your machine, from your files, and designs are saved in a local workspace.A launcher, and the runtime it installs. The plugin carries only the launcher:
runtime/codesign(codesign.cmdon Windows), readable JavaScript modules inruntime/codesign-shim/that run on your Node.js, andruntime/snapshot.json, the tool list it answers with until the runtime is installed. The runtime (CoDesign with its own Node.js, a CE.SDK engine and its assets) is downloaded into~/.codesignfrom IMG.LY's release server,https://get.codesign.co/runtime/<channel>/, and checks there for an update every 6 hours. Every download is listed in a release manifest signed with IMG.LY's Ed25519 key, which the launcher carries, and must match the SHA-256 and size the manifest gives; a manifest older than the last one accepted is refused.No hooks. The plugin runs nothing at session start. When the runtime is missing, the server answers from
runtime/snapshot.jsonand installs it in the background on its first start.What your agent reads from it. The MCP instructions, tool descriptions, skills and prompts ship inside the signed runtime release (until it is installed, in the plugin's
runtime/snapshot.json); nothing fetches them from anywhere else.Where it connects:
get.codesign.co: runtime downloads and update checks.cdn.img.ly: templates, fonts, other default assets and the browser editor.img.lyandclerk.img.ly: the IMG.LY sign-in, only when you sign in with thelogintool.gateway.img.ly: only for AI generation.api.img.ly: usage data, and Sentry (sentry.io): error reports. In Claude Code, turn them off in the plugin's settings (Send usage data to IMG.LY, Send error reports to IMG.LY); on any host, setDO_NOT_TRACK=1orIMGLY_TELEMETRY=off.Addresses a design, you or your agent name, such as an image or font URL: fetched and copied into your workspace.
IMG.LY's CE.SDK engine, which renders and exports, itself checks its licence with IMG.LY (
api.img.ly) and reports its own usage there when it starts; neither the plugin's two settings norDO_NOT_TRACKturn that off.
Requirements & known limitations
Read this first — the failure modes below are silent.
Node.js is required and is not provided. The plugin needs Node.js ≥ 18 on
PATH: Claude Code until the runtime is installed, Codex, Copilot CLI, Antigravity and Cursor (untested) on every start. On an older Node the server says what to install. With no Node at all the host cannot start it and reports the server as failed with no useful reason — typicallyspawn node ENOENT,local: 0orMCP error -32000. The direct recipes need Node.js ≥ 22.15. Install Node first: https://nodejs.org, or see https://codesign.co/install.The plugin updates itself. It installs the runtime of its channel and checks for an update every 6 hours; no plugin update is needed to move forward.
Pin
@0.7.0— every direct recipe names that exact version. Each release republishes this repo with a new pin — update your recipe to move forward.Windows: the direct recipes need WSL. Hosts that spawn
npxdirectly hitspawn npx ENOENT(anthropics/claude-code#58510). The plugin runs nonpxand needs no Git. Claude Code, Codex and Copilot CLI start it natively on Windows; Antigravity and Cursor on Windows are untested. Without Node, Claude Code can use the plugin if you first runirm https://get.codesign.co/runtime/stable/install.ps1 | iex.
Install
Claude Code
Install the plugin from the marketplace:
claude plugin marketplace add imgly/codesign
claude plugin install codesign@imgly-codesignOr add the MCP server directly, without the plugin:
claude mcp add --scope user codesign -- npx -y @imgly/codesign-mcp@0.7.0 stdioCodex
Install the plugin from the marketplace:
codex plugin marketplace add imgly/codesign
codex plugin add codesign@imgly-codesignOr add the MCP server directly, without the plugin:
codex mcp add codesign -- npx -y @imgly/codesign-mcp@0.7.0 stdioAntigravity CLI
Clone the repo and install the plugin folder:
git clone https://github.com/imgly/codesign
agy plugin install ./codesign/plugins/codesignOr add the MCP server directly, without the plugin:
agy mcp add codesign -- npx -y @imgly/codesign-mcp@0.7.0 stdioGitHub Copilot CLI
Install the plugin from the marketplace:
copilot plugin marketplace add imgly/codesign
copilot plugin install codesign@imgly-codesignOr add the MCP server directly, without the plugin:
copilot mcp add codesign -- npx -y @imgly/codesign-mcp@0.7.0 stdioCursor
In Cursor, open Customize, choose From GitHub Repository, enter https://github.com/imgly/codesign, then Install the CoDesign plugin (untested). On a Teams or Enterprise plan, an admin can instead add the same URL as a team marketplace with Import from Repo, and teammates install CoDesign from Customize.
Or copy the plugin folder into Cursor’s local plugins, then run Developer: Reload Window (untested; on Enterprise, an admin must allow local plugin imports):
d=$(mktemp -d) &&
git clone --depth 1 https://github.com/imgly/codesign "$d/codesign" &&
mkdir -p ~/.cursor/plugins/local &&
rm -rf ~/.cursor/plugins/local/codesign &&
cp -R "$d/codesign/plugins/codesign" ~/.cursor/plugins/local/ &&
rm -rf "$d"Or add the MCP server directly, without the plugin, in .cursor/mcp.json:
{
"mcpServers": {
"codesign": {
"command": "npx",
"args": [
"-y",
"@imgly/codesign-mcp@0.7.0",
"stdio"
]
}
}
}Other MCP hosts
Every other host spawns the same stdio server — only the config file and the top-level key differ. Add this block to the host’s MCP config:
{
"mcpServers": {
"codesign": {
"command": "npx",
"args": [
"-y",
"@imgly/codesign-mcp@0.7.0",
"stdio"
]
}
}
}Host | Config file | Note |
Windsurf |
| as-is |
VS Code |
| use the key |
Zed |
| use the |
VS Code (servers key):
{
"servers": {
"codesign": {
"command": "npx",
"args": [
"-y",
"@imgly/codesign-mcp@0.7.0",
"stdio"
]
}
}
}Zed (context_servers):
{
"context_servers": {
"codesign": {
"command": {
"path": "npx",
"args": [
"-y",
"@imgly/codesign-mcp@0.7.0",
"stdio"
]
}
}
}
}Beyond your machine
CoDesign runs free on your machine today. When you need more — always-on hosting, your own infrastructure (VPC / on-prem), or a fully bundled design agent that lives in the canvas — the same building block graduates by changing config, not vendors. No lock-in. Talk to us: support@img.ly.
Support
Questions or issues: support@img.ly. This distribution is generated from IMG.LY's source repository.
Available Tools
19 toolsasset_addA
Add a local image or font file to the workspace so it can be used in a design. Copies the file bytes into the content-addressed asset store at assets/<sha>.<ext>. The bring-your-own arm of the asset family: asset_search finds an existing asset, asset_generate makes one, asset_add takes one off your disk — all three return a workspace:// uri to embed in edit. (To turn a design FILE into a new design, use import.)
Returns JSON: { uri, httpUrl, mimeType, kind, bytes, note? }. uri (a workspace:// URI) is the durable handle — embed it in a subsequent edit (image fill, or engine.asset.apply; for a font, as both setFont's uri and typeface.fonts[].uri), NEVER httpUrl and NEVER the original file:// path, so the design stays loadable after a restart or rewind. httpUrl is a fetch link for opening the asset now.
Files are classified by content (magic bytes) first, extension second: a misnamed file is stored under its actual type, and note explains any correction, rescue, or unverifiable content.
Make-available only: it never edits a scene and never creates a revision — do the placement in edit.
Source: { path } — an absolute path to a file the server can read. Local-only (this backend shares your disk); on a hosted server this arm is not offered.
Inputs: source (required).
asset_generateA
Generate images (text-to-image, image-to-image) via the IMG.LY AI gateway.
Call with NO arguments first: returns the model catalog — pick a model, then call again with model + prompt (+ optional format aspect like "16:9").
For image-to-image, pass image_uris with workspace:// URIs (from import or earlier generations).
The first content part is JSON: { uri, httpUrl, mimeType, bytes }. uri (a workspace:// URI) is the durable handle — embed it in subsequent edit calls. httpUrl opens the asset directly. The parts after it are a labeled thumbnail of each generated image — look at them; the JSON alone does not tell you what was drawn.
Multi-output models (layerize-class: decompose an input image into layers) add an assets array to that JSON — one entry per image, { index, uri, httpUrl, mimeType, bytes }, in stack order (residual background first, then cutout layers). The top-level fields mirror assets[0]. Single-output results carry no assets array. Any non-image output the model produced is passed through VERBATIM under metadata — read it, it binds semantics to the assets (layerize, for example, ships a layers list in assets order with names, z order and bounding boxes in source pixels; cutouts are cropped to content, so place them by their bounding box).
Requires a free IMG.LY sign-in (the login tool); all other design tools work without an account.
Inputs: model, format, prompt, image_uris.
asset_searchA
Discover the asset sources registered on the CreativeEngine and search the assets they contain. Read-only — never creates a revision.
Without sourceId: lists every source id with its supported MIME types.
With sourceId: returns one page of assets as JSON { total, currentPage, nextPage, assets: [{ id, label, groups, uri, thumbUri, width, height, uploadedAt }] }. Typeface assets (e.g. the ly.img.gfonts Google Fonts source) additionally carry a compact typeface: { name, weights, styles } summary. query fuzzy-matches labels and tags.
The ly.img.workspace.images source is this workspace's own image store: every image the agent generated or imported AND every image the human uploaded in the browser editor, newest first. Uploads carry their original filename as label (the human will refer to it — "use logo-final.png" — so search that name), plus groups: ["uploads"] and an uploadedAt timestamp. "The image the user just uploaded" = the uploads-group asset with the newest uploadedAt.
⚠ Asset sources are deployment configuration — where their content lives (IMG.LY CDN, a customer host) is the server's business. NEVER fetch asset manifests (content.json) or hardcode cdn.img.ly URLs yourself; this tool and engine.asset.* are the only correct path. A source missing from the no-arg listing is not available on this server — say so instead of working around it.
To USE a result, apply it inside edit code — re-find it there, then either:
(A) new block: const id = await engine.asset.apply(sourceId, (await engine.asset.findAssets(sourceId, { query, page: 0, perPage: 1 })).assets[0]) — then, if you resize the frame, set engine.block.setContentFillMode(id, "Cover") (resizing does NOT update the crop; without Cover a portrait photo forced into a landscape frame gets squished);
(B) existing block: const fill = engine.block.createFill("image"); engine.block.setString(fill, "fill/image/imageFileURI", asset.meta.uri); engine.block.setFill(blockId, fill); engine.block.setContentFillMode(blockId, "Cover").
(C) fonts: re-find the family inside edit code and pass the payload straight to setFont — const { assets } = await engine.asset.findAssets("ly.img.gfonts", { query: name, page: 0, perPage: 20 }); const tf = assets.map((a) => a?.payload?.typeface).find((t) => t?.name === name); if (!tf) throw new Error("font lookup missed: " + assets.map((a) => a?.payload?.typeface?.name).join(", ")); engine.block.setFont(id, tf.fonts[0].uri, tf); engine.block.setTextFontWeight(id, "normal"). Take the EXACT name out of a page of results — fuzzy ranking can put it behind longer names (query "Lora" returns Explora first), so perPage: 1 fetches the wrong family. And always set the weight: tf.fonts[0] is the family's LIGHTEST declared weight (Thin/100 on Inter, Roboto, …), so setFont alone renders hairline text with no error. Never copy font URIs out of this tool into edit code.
Do NOT use engine.asset.applyToBlock — on this server it silently no-ops (the block keeps its old fill, no error).
Inputs: page, query, perPage, sourceId.
changesA
Check whether the user changed a design in the browser editor since you last touched it.
Pass the revision you believe is current — normally the one your last edit returned. The reply says whether it is still the design head and lists what was written since, oldest first, with each revision's diff note and whether it came from the editor (origin: "editor") or from your own edit.
Call this before your first edit of a design whenever the user may have had the view page open: edit REJECTS a parent whose path to the head contains one of the user's editor saves, so this is how you find the parent to build on.
Inputs: revision (required).
checklistA
Register the brief's ACCEPTANCE CHECKLIST for a design — the machine-checkable claims that must hold before the work counts as done. Do this right after intake, before the first edit: extract from the brief every required output file, every string of approved copy that must land verbatim, and note the constraints only you can check.
Item kinds:
{ kind: 'output', path } — a file that must exist when the design is delivered (absolute path, e.g. every variant the brief orders exported).
{ kind: 'copy', text } — approved copy that must appear VERBATIM in the design's text (whitespace variants are folded before comparing; wording, case and punctuation are exact).
{ kind: 'note', text } — a self-check the server cannot verify (e.g. "layout structure unchanged from master"). Kept on record; never machine-checked.
Every export verifies the current checklist against the deliverable and lists unmet items in its result — treat an unmet item exactly like a failing test: finish the work, or re-register the checklist without the item if it is genuinely obsolete. Calling checklist again REPLACES the whole list for this design.
Returns: { ok, itemCount, rootRevision } — or the current checklist when called with only revision (no items).
Inputs: revision (required), items.
diagnosticsA
Inspect this codesign MCP server: status (default) reports what is running (build id, CE.SDK engine version, non-secret config); summary returns a bounded digest of recent activity (counts, recent errors, slowest calls); open returns a clickable local viewer URL with a Download-ZIP button to send diagnostics to IMG.LY.
Inputs: action.
editA
Edit the CE.SDK canvas by running JavaScript against the live CreativeEngine, then commit the result as a new revision.
⚠ Call skill({ name: 'handbook' }) BEFORE your first edit. It documents the design loop, the typeface schema, and the engine recipes; on cryptic errors, query its quirks.md.
REQUIRED: parent is a revision id (returned by a previous edit), or the JSON null literal (no quotes) to start a new design. Omitting it is an error — there is no implicit 'continue from wherever'. In a fresh conversation, a request for a new design means parent: null — never resume a workspace design the user didn't reference.
Returns: the first content part is JSON { revision, parent, names? } — store revision so you can pass it as parent on the next edit. names lists every named block in the committed scene: those are exactly the strings engine.design.findByName(name) resolves in your NEXT edit, so name what you build and re-find it instead of matching copy. When the edit changed the scene, the result also ends with a downscaled render of the (first) changed page — verify your work from it instead of spending a preview call. preview remains required for full-size judging (the judge loop) and multi-page review; set render: false to skip the image on read-only/diagnostic edits.
code return contract (STRICT): return undefined (no message back), { type: "text", text }, { type: "image", data: "<base64>", mimeType }, or an array of those. Anything else (raw strings, Blobs, plain objects) is rejected.
DIALECT (enforced): mutations go through engine.design (create/build/setProps/…). Code that mutates via engine.block.* is rejected before execution with the equivalent calls; // engine.block: <reason> opts out for calls the facade lacks.
code scope: engine (with engine.design), plus findText(copy) / findAllText(copy) for reaching a block by its text. Use them instead of comparing text strings with === — the copy on the page routinely carries a trailing space or an NBSP (before a €/%), which is what makes hand-rolled lookups throw. Matching folds those space variants and trims; a miss lists the copy actually on the page.
Dirty-on-throw: if your code throws, the engine slot is marked dirty and the next edit pays one engine reload (regardless of parent). Do not catch-and-swallow errors that should propagate — let them throw so this safety contract kicks in.
Optional: title (set on parent=null only — the design's display name) and note (a one-liner describing what this edit accomplished — purely descriptive, helps you re-ground after a rewind).
Refused parents: if the user saved changes in the browser editor between your parent and the design head, this edit would discard them, so it is rejected — call changes to see what they did and which revision to build on.
Inputs: code (required), parent (required), fork, note, +2 more.
exportA
Export a revision to a final deliverable — format picks it: pdf (print PDF), png/jpeg/webp (image), svg (vector SVG), pdfx (print-ready PDF/X), html (responsive HTML5), imgly (editable design file). Renders blockId — or the whole document when blockId is omitted — and writes the result into the workspace under exports/<shard>/<rev>/ (revision-pinned, deterministic).
Returns JSON: { uri, httpUrl, bytes, format, revision } (plus path when you pass outPath). uri (a workspace:// URI) is the durable handle. httpUrl is a fetch link tied to this process — fetch it to download the bytes to disk, or hand it to the user.
outPath (optional, absolute path including the filename): ALSO write the artifact to that local path — the workspace copy is still written, and the response then carries path. Use it when the file is wanted on disk, and always when your environment cannot fetch localhost URLs (sandboxed harnesses, e.g. Claude Cowork — target your session's outputs folder there).
format=svg is the engine's vector export: text is outlined into paths (renders identically everywhere, but is not editable text in the SVG), and raster images are embedded in the file at source resolution — an SVG of a photo-heavy design can be much larger than its source images.
format=imgly writes a portable, self-contained .imgly design file (scene + all asset bytes bundled) — the inverse of import, and the only format that stays editable. Whole-design only: blockId is not accepted. Every edit already auto-persists to the workspace, so you never need this to keep your work — use it to take an editable copy OUT: hand it to a human, back it up, move it between servers.
format=pdfx runs the print PDF through a PDF/X conversion (Ghostscript): CMYK with an embedded ICC profile and PDF/X conformance markers, ready for a print shop. Tune it via the optional pdfx object — conformance standard (X-4 default / X-3), output profile (fogra39/gracol/srgb/custom), transparency flattening, OutputIntent metadata. Conversion adds a few seconds.
format=html renders ONE page (blockId required — pass a page id) to responsive HTML5. Default is a single self-contained .html (assets inlined; animated designs get a CDN GSAP player injected so the file plays as-is); html: { assets: "external" } delivers html + separate image/font files as one .zip.
Inputs: format (required), revision (required), html, pdfx, +2 more.
historyA
Walk back from revision to the root, returning the chain (root first). Each entry has { revision, parent, note?, origin?, createdAt } — origin: "editor" marks a revision the user saved from the browser editor. Use this to re-ground after a rewind: read the notes, pick the revision you want to continue from, pass it as parent to your next edit. Continue a prior design only when the user asked for it — never because it is the newest entry.
Inputs: revision (required).
importA
Import a design FILE as a NEW design root revision — a native CE.SDK .imgly design file (also the legacy .scene and .zip forms); a foreign design file: Photoshop (.psd/.psb), InDesign (.idml), PowerPoint (.pptx), or PDF; or a plain image (PNG/JPEG/WebP/GIF) or SVG, which becomes a one-page design sized to the image (format: "image"/"svg"). The inverse of export({ format: 'imgly' }). To make a media file (image/font/video/audio) available for use INSIDE a design instead of becoming one, use asset_add.
Source: { url } (http/https), { demo } (a design bundled with this server — ids: "cybernews") or { path } (absolute local file path; Local only). Archives are ingested: bundled asset bytes are extracted into the workspace as content-addressed assets/<sha>.<ext> files, so the loaded design is durable and behaves exactly like a natively-built one.
Returns JSON { revision, title, format } — continue with edit({ parent: revision, … }). Foreign-format imports may add warnings (importer notes about what did not survive — substituted fonts, unsupported features): treat them as your touch-up list — preview the pages, then repair with edit; find replacement fonts via asset_search. Bare scene-file loads (no bundled assets) additionally return assets: a classification of every referenced asset URI by scheme (workspace / external / bundle / transient / other). External URLs are NOT fetched; transient entries WILL be lost on the next save — replace or relocate them before committing further work.
Engine caveat: InDesign and PDF import need the WASM engine (IMGLY_CESDK_ENGINE=wasm) — on the native engine import errors cleanly for those two formats; Photoshop and PowerPoint import work on both.
Inputs: source (required), title.
inspectA
Read one revision in full: parent, note, createdAt, title (root only), and the JS code that produced it (when written via edit).
Use this after history when you've picked a revision and want to know HOW it got there — the code is the precise operation; note is the agent's summary.
Returns JSON { revision, parent, note?, origin?, createdAt, title?, code? } — origin: "editor" marks a revision the user saved from the browser editor. code is omitted for revisions not produced by edit (e.g. future import paths).
⚠ Past code reveals the PATTERN of an edit (which APIs were called, what kind of block was targeted), NOT the block ids. Block ids are session-scoped — re-discover them in the current engine; don't replay the literal numeric ids.
Inputs: revision (required).
listA
List designs in the workspace. Returns an array of { rootRevision, title, latestLeaf, updatedAt, headOrigin?, headNote? } sorted newest-first; the head* fields describe latestLeaf. headOrigin: "editor" means the last hand on that design was the user's, in the browser editor — read headNote (the engine-computed diff of their save) before you change anything, and build from latestLeaf so their work is not discarded. Use when the user asks what designs exist or wants to resume earlier work. Seeing a design here is never by itself a reason to continue it — for a new design request pass parent: null to edit.
Inputs: no named parameters.
loginA
Sign in with your IMG.LY account (opens the system browser). The session saves automatically once the user finishes in the browser; call login again anytime to confirm — safe to repeat, it does not restart the flow or invalidate the open link. Pass switch_account=true to sign in as a different user.
Inputs: switch_account.
logoutA
Sign out of your IMG.LY account (revokes the session and clears local credentials).
Inputs: no named parameters.
previewA
Render blocks (almost always pages) to inline images so you can see the result.
revision is REQUIRED — pass the revision the blocks belong to, the id edit returned. blockIds is a LIST, rendered in the order you give it: [pageId] for one page, [a, b] for a subset, or OMIT it entirely to preview every page of the design in document order.
The given revision is loaded before rendering, so the ids always resolve against the right scene — never against a different design another agent may have loaded on a shared server.
Preview several blocks at once when REVIEWING or capturing a finished design — a whole deck in one call, or just the pages a fix touched. While BUILDING a multi-page design, keep previewing each page right after you build it: batching there does not avoid the bugs, it only delays finding them.
Output is always PNG (lossless — thin lines render exactly). EACH block gets the full 0.25 megapixel budget, adjusted to its own aspect ratio — a square page renders 512×512, a 1:4 page 256×1024. There are no size or format knobs, and at most 10 blocks render per call.
To eyeball fine detail, preview the suspect BLOCK directly — the pixel budget concentrates on it (an effective zoom). For native-resolution certainty, export the page and open its httpUrl.
Inputs: revision (required), blockIds.
renameA
Rename a design. revision may be any revision in the lineage; the root's title is updated. Use this when the title set at design creation no longer fits.
Inputs: title (required), revision (required).
scorecardA
Record the verdict of a judge loop you have COMPLETED for a revision — the final step of the judge skill. Recording is a claim about work already done: never call this without having scored the axes against actual preview renders of this exact revision's content.
verdict: 'pass' — every applicable axis scored ≥ 8; the design may be delivered. verdict: 'fail' — you are stopping with an axis below 8 (e.g. the user cut remediation short); the failure stays on record.
The latest scorecard is what export checks: delivering a revision it does not cover (content changed since, or no scorecard at all) adds a reminder to its result. Judging again after further edits? Record a new scorecard for the re-judged revision.
Inputs: verdict (required), revision (required).
skillA
Load a skill — an instruction document that teaches you how to work with this server. Read the relevant skill BEFORE attempting work it covers. Intended sequence: (1) call with just name to get the entry document — it ends with an index of the bundled files; (2) pass query (a regex, like Grep) to search the bundled files for the rules you need, scoping with path when you know the file; (3) full-read a file via path only when it is small (the index shows line counts) or after a search missed twice — slice large files with offset (skip count: offset=10 starts at line 11) and limit. Entry documents are always returned whole (offset/limit are ignored for them).
<available_skills> The CoDesign design loop, tool contract, workspace cheatsheet, typeface schema, common operations cheatsheet, and the full design-quality rubric. Read this skill before any edit call — it contains the 5-step Loop (decide parent → read API → exec → preview → judge), the tool roster and cross-tool rules, the workspace revision model (list / history / rename), rewind-recovery procedure, the typeface shape text.font declarations need, and §6: the design-rules index — the full enforceable rubric (typography, hierarchy, composition, craft) ships as this skill's design-rules.md, the runtime-quirk reference as its quirks.md, and the input-resolution contract every skill follows as its intake.md, all read on demand.
Triggered for any task using this server's edit or preview tools.
Authoritative TypeScript signatures for the CE.SDK CreativeEngine. Use this
skill whenever you need the exact signature, parameter types, or return type
of an engine.* method — especially before calling a method you haven't
used yet. This is THE source of truth for signatures: generated from the
.d.ts shipped with the same @cesdk/node package the engine runs, while
prose docs (the guide skill) can drift.
Reading this skill with no path returns the WHOLE edit-code API surface inline — the engine.design facade, the props trees, the attachment unions and the capability matrix. That is one call and it is all edit code needs.
The sub-file "signatures.d.ts" is the same surface plus the upstream CE.SDK core — JSDoc-free signatures with every string-vocabulary type (property names, block types, enum values) flattened to its literal union on the declaring line. It is served a page at a time: search it with query (e.g. query: "saveToArchive"), then slice around the hit with path + offset/limit.
Triggered when you need to verify an engine.block.* or engine.scene.*
signature, look up a parameter type, or confirm an enum/string-property name.
Use when applying a brand kit / brand style to an existing CoDesign / CE.SDK design — a
rules-governed restyle (recolor + refont + logo + treatment by role), not a free-form style
change; when a restyled design reads off-brand (free-chosen colors, wrong accent, a second
colour used as structure, a coloured button the brand forbids, a headline set in a weight the
brand bans, a flat bordered card, or the wrong / recoloured / redrawn logo); when loading a
brand's fonts, wordmark SVG, or signature device into a scene; or when turning an external brand
(a guidelines PDF, a website / URL, a Figma file, or a raw asset dump) into a reusable brand kit.
Use when the user asks to create / generate / make a NEW design from a prompt — a deck
or slides, poster, flyer, social post, business card, or a custom-size canvas. Runs the
guided intake: derive every brief parameter the prompt already answers (class, format,
audience, vibe, brand, content), ask ONLY the missing questions — one round, chip-style
options, "Decide automatically" defaults — then echo the design brief and hand off to the
handbook Loop. A brief given to the /codesign prompt lands here as the stated input.
Canvas-format reference for CoDesign designs — one file per screen/print format (ig-post,
ig-square, ig-story, widescreen, linkedin-post, x-post, deck, poster, flyer, business-card):
exact W×H, aspect, medium, platform safe zones, print bleed/dpi. Use when picking or setting up
a canvas size, checking a platform safe zone, or preparing print dimensions. Re-composing an
existing design into a format is the resize skill; new-design intake is the create skill.
Look up CE.SDK Node.js reference docs, guides, and configuration pages —
prose explanations, recipes, and concept docs for everything the engine can
do (text, fills, colors, export, video, templates, asset sources, …).
Use when you need to understand HOW a CE.SDK feature works or want a code
recipe; also triggered by "IMG.LY", "CreativeEditor", "CE.SDK", or "cesdk"
when the user needs an existing Node.js doc page. For exact TypeScript
signatures use the api skill instead.
The entry document is an index; every doc page is a sub-file — read one with
path (e.g. path: "text/add.md"), or search them all with query.
Use to quality-gate a design before reporting it done — the mandatory step 5 of the
handbook Loop; when the user asks for a design review, score, audit, or QA; or when a
design needs remediation after a failed review. The axes, the gate, the scorecard
format, and the remediation loop are defined in this skill's body — read it before
scoring; do not judge from memory of this description.
Use when creating or fixing translated / localized variants of an existing CoDesign / CE.SDK
design (e.g. de/ja/ru/ar editions); when a localized edition's text blocks or
decorative elements have drifted, re-centered, or resized away from the source layout; when
translated copy is tofu, overflowing, mis-tracked, or the wrong font after a language swap; or
when loading a non-Latin script (Cyrillic / CJK / Arabic RTL / Vietnamese) font into a scene.
Use when the user is new here or asks what this server is / what it
can do ("what is CoDesign", "what can you make", "show me"). A guided, plain-language
introduction for a HUMAN: explain what CoDesign is in everyday terms, put the six
jobs it does on the table, let the user pick one, then run it either on the bundled
demo design or on the user's own idea — closing with the optional (never required)
IMG.LY sign-in and the ways to earn more credits. Not a design manual: the handbook
remains the required read before any edit.
Use when resizing or reformatting a CoDesign / CE.SDK design to a new size or aspect ratio
(ig-post ↔ ig-square ↔ ig-story ↔ widescreen, or a custom W×H); when building the size/format
editions of a design from an existing design or from a brief; or when a reformatted
edition has a dead void / letterboxed empty band, drifted or broken margins, off-canvas or
clipped elements, mis-scaled decoration, or a stretched / squished layout.
</available_skills>
Inputs: name (required), path, limit, query, +3 more.
viewA
Get a URL the human can open to view and edit the design in CE.SDK. Returns the design's stable URL — the viewer keeps it live, re-rendering as you edit, so print it ONCE and don't re-emit a fresh URL every turn. Add pin: true for a frozen permalink to that exact revision (for 'look at exactly this' or comparing revisions). The page is a full editor; when the human clicks 'Save', their edits land as a new revision whose note carries an engine-computed change summary — continue from that revision.
Inputs: revision (required), pin.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 19 tools
Each tool targets a distinct concern: revision lifecycle, asset management, auth, skills, export, or diagnostics. The asset_search/asset_add/asset_generate trio is clearly separated by operation (find/add/generate), and list/history/changes/inspect are differentiated by scope. No two tools appear to overlap in a way that would cause misselection.
Bare verbs (edit, export, preview, import, list, view) coexist with prefixed names (asset_search, asset_add, asset_generate) and noun-only names (skill, history, checklist, scorecard, diagnostics). While the core verbs are recognizable and readable, there is no single predictable pattern across the set.
At 19 tools, the server sits in the 16-25 range that feels heavy. However, the broad scope (design editing, assets, auth, skills, diagnostics, quality gates) justifies most of them, so it is borderline rather than bloated.
The design lifecycle is well covered: create (edit, import), read (inspect, preview, history, list), update (edit, rename), and export, plus asset management and quality gates. The main gap is the absence of delete/remove operations for designs or assets, and asset management lacks update/delete, but agents can work around these.
Maintenance
Related MCP Connectors
Make branded PDFs and images from reusable templates, brand kits, and your data.
Give your AI agents a design superpower. Generate, edit, and publish publication-grade decks, reports, landing pages, resumes, and marketing visuals directly within your agent workflow. Delivering frontier-level design quality at 3× the speed and 53× lower cost -from conversational prompt to live link or vector PDF in minutes.
Your design, automated endlessly. Design anywhere, Brixa freezes it as a template, publishes forever
Render PDFs and images from your Typefold templates, and build visual templates.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables Cursor to access Figma design data via MCP, allowing it to fetch simplified layout and styling information to accurately implement designs from Figma files.2,146 npmMIT
- AlicenseAqualityAmaintenanceEnables AI assistants to control Adobe Photoshop programmatically, supporting recipe workflows, state awareness, and generative AI features through natural language commands.1289,794 npm876MIT
- AlicenseAqualityBmaintenanceLocal-first visual design workspace for AI assistants. Compose wireframes and branded multi-page HTML/CSS documents with live preview, annotations, brand and asset libraries, typed data collections, layout validation, PDF export, and draft-only Gmail handoff.1629 npm20MIT
- AlicenseNot gradedqualityDmaintenanceMCP server for design decisions during a build, providing live UI/animation library docs (via llms.txt) and a curated knowledge base of UX laws and UI conventions. It enables agents to look up real component APIs and apply design best practices, running locally via stdio or hosted on Vercel.6 npmMIT