Connect Claude to a creative canvas with MCP

When you work with a large language model in a creative environment, the most common point of failure isn't the model's reasoning, it's the data it can see. Many workflows still rely on a copy-paste style, where a person describes a canvas, a prompt, or a generated result to a chatbot by hand. That inevitably leads to context drift.

Context drift is when an agent's understanding of a project diverges from the actual state of the work over time. Standard LLM chats are stateless and disconnected from the tool's live state, so the agent loses track of which nodes exist, how they're wired, and which generation produced which output. It might remember a video node from three prompts ago with no way of knowing it was since deleted, re-run with a different model, or rewired to a new source image. Without a protocol-level bridge, the model stays blind and you become the manual data translator.

A standard bridge for creative work

Can a standard protocol close the gap between creative software and external AI models? The Model Context Protocol (MCP) helps by defining an open interface that lets an agent connect to a server and call its exposed tools and resources. The developer community first adopted MCP to connect LLMs to IDEs and terminals, but the same pattern applies to creative software: expose the workspace as structured, queryable data instead of a flat screenshot.

Melius does exactly this. Its canvas is organized as Team → Projects → Canvas → Nodes + Edges → Runs. A canvas is a 2D workspace; nodes are creative units (text prompts, images, videos, audio, files); edges wire nodes together to pass data between them; and a run executes AI generation on a node, taking its prompt, model config, and upstream inputs and producing an output. Over MCP, an agent reads that live node-and-edge graph and acts on it directly, rather than guessing from a description.

Connecting Claude to Melius

Connecting takes a couple of minutes. The quickest path is the hosted connector: add a custom MCP connector in your host, point it at https://mcp.melius.com/mcp, then log in and pick a team when the authorize page opens. For the full walkthrough, including the local server for development and how credentials work, see the Melius MCP docs.

What the agent can actually do

Once connected, the host gets a focused set of capabilities that mirror how the canvas works, rather than one opaque API. At a high level, an agent can:

• Read the live canvas: what's on it, how the pieces are wired together, and each one's current output, all from the same live state your browser sees
• Understand what's possible: which generation models are available and what each one needs, so it works from real capabilities instead of guessing
• Compose the work: add, arrange, and wire together the pieces of a creative pipeline
• Run and follow through: kick off generations and act on the results as they come back

So a prompt like generate a product shot, then animate it into a 5-second clip becomes a short pipeline the agent assembles and runs on the real canvas, not a visual approximation. It is the brief-to-execution workflow driven from your own agent. The exact shape of that surface is where a lot of the craft lives, so we'll leave the finer mechanics to the platform.

A self-correcting loop

One genuinely useful property falls out of exposing the canvas as structured data: the platform rejects stale or hallucinated references. Everything the agent points at has to resolve against the live canvas. If it references something that no longer exists, the call fails with a correction that sends it back to re-read the current state. A common failure mode, an agent confidently referencing something that isn't there, becomes a caught error and a re-scan, so the agent corrects itself instead of silently producing broken or failed work.

Bring your own model

Melius is model-agnostic at the host level: because the connector speaks standard MCP, you can drive it from any compatible host. Keep the two models in play distinct. The host model is the reasoning agent that reads the canvas and decides what to do; the generation models, the ones that actually produce images, video, and audio, are the ones available on the platform and selected per node. The agent orchestrates; the media models generate.

By connecting the Melius MCP server, you aren't bolting on a black-box AI button, you're giving an external agent live, structured access to your canvas, so it has the context it needs to be genuinely useful. Start creating with Melius.

Frequently asked questions