> ## Documentation Index
> Fetch the complete documentation index at: https://agent.minimax.io/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# AI Node Canvas

> Lay every step out on one canvas: a node is a real model run, and a line is a data path. Image, video, prompting, and media editing all happen here.

> [!NOTE]
>
> AI Node Canvas is a MiniMax Code MiniApp contributed by the community, developed and maintained by antianqi. Version 1.22.9 has been merged into the official MiniApps repository: [MiniMax-AI/MiniMax-Code-MiniApps](https://github.com/MiniMax-AI/MiniMax-Code-MiniApps/tree/main/plugins/antianqi/ai-node-canvas). This page describes that version. Thank you, antianqi, for contributing to the MiniMax Code community!

> [!NOTE]
>
> Screenshots on this page show the Chinese UI.

Lay every step out on one canvas: a node is a real model run, and a line is a data path. Image generation, video generation, prompt writing, and media editing all happen on this one canvas.

## Every step is visible

The clip comes out wrong — was it the prompt, the reference image, or just how the model behaved on this step? In a chat, that usually leaves you with "try again," and the in-between work stays invisible.

AI Node Canvas lays every step on the canvas: who produced this card, what it connects to, and where it went wrong, all at a glance.

![A finished pipeline on one canvas: generate an image → multi-angle → write a storyboard → split the audio → final clip, 10 nodes and 8 connections](https://mintcdn.com/agent-en/V3Bs5jNsIrlVwtOq/images/community/ai-node-canvas/01-overview.jpg?fit=max\&auto=format\&n=V3Bs5jNsIrlVwtOq\&q=85\&s=36db78f6c6bf48d924fec669faa9b9fe)

* **A node is a real model run.** Click to run it, and the result stays on the same card — a new card does not appear beside it.
* **A line is a data path.** Upstream outputs are injected into the downstream prompt as reference material, with no manual download and re-upload.
* **If a run fails halfway, earlier results stay where they are.** Each node's output is the card on the canvas; you only rerun the broken path.
* **Change one card, and only that path reruns.** The prompt, model, aspect ratio, and reference images live on the node — you can change a parameter without starting over, and without having to reproduce the last result by hand.

### Nodes and connections carry four kinds of data

A node has two dimensions: role (input / generate) and data (text / image / video / audio). An input node carries one of the four types; a generate node produces one of the four. A result node is left behind by a tool or a finished run; a group is a frame around other cards. The only data that flows along connections is text, image, video, or audio — style presets and expanded prompts are text, not separate types.

The plugin does not own the models: every run goes through the host Agent, which means the MiniMax models you are already using. You do not configure an API key or store credentials, and the plugin itself does not send model requests.

## All generation and media live here

One app for images, another for video, prompts buried in a chat log, and a third tool for editing — assets get passed around three times, context can drop on every handoff, and when something goes wrong it is hard to tell which step lost it.

All of that happens on the same canvas: write the prompt here, generate the image here, generate the video here, and edit the media here.

| What you want to do | Where on the canvas | How |
| - | - | - |
| Write a prompt | Prompt-enhance node | Write a rough one-liner, pick a format template, and it runs one text pass to rewrite the prompt into something the model can follow |
| Generate an image | Image node | Pick the model, aspect ratio, and resolution on the node, click Generate, and the result lands on that card |
| Generate a video | Video node | H3's five shapes: text-to-video / first frame / first-and-last frame / last frame / full reference |
| Generate audio | Audio node | Read text as speech, or generate a music bed |
| Edit media | The toolbar on a node | Trim, extract frames, split audio, cut out a subject, upscale — click one tool to run it, and the result becomes a new node on the canvas |
| Reverse someone else's recipe | Text node | Video-to-text / image-to-text: read a clip or an image back into a prompt you can reproduce |

### Writing prompts: format templates fill in the rest

| Format | What it fills in |
| - | - |
| Ecommerce hero | Subject + material detail + scene lighting + composition and camera + quality |
| Short-video storyboard | Timecode + shot size + camera move + action + mood + sound |
| Portrait | Appearance + wardrobe + pose and expression + lighting + background + lens and quality |
| Product texture | Material and structure + usage scene + light and shadow + macro detail + background |
| Social cover | Main title + visual subject + color + whitespace and layout + platform size |

The node also has 4 style presets: product hero, S+ 详情, social cover, and portrait.

7 workflow templates are built in: image recreation, video imitation, and H3's five shapes. Applying a template costs nothing — you are only laying down a skeleton; running it is what costs quota.

### Image generation: 4K by default, 16 reference images

Image generation is the step that runs most often on the canvas, and the image model is MiniMax-H3-Image: leave the node blank, and the output is 4K, with the aspect ratio following the prompt. Image-to-image can take 16 reference images in one request — multiple angles and camera setups of the same subject, in a single request.

If you do not set an aspect ratio, the frame follows the prompt. If you want a fixed ratio, there are 6 options: 1:1 / 16:9 / 9:16 / 4:3 / 3:4 / 21:9.

Available models: MiniMax-H3-Image, MiniMax-H3, MiniMax-H3-Max, MiniMax-Hailuo-2.3, Matrix speech synthesis, and Matrix music generation. Model coverage follows the M Plan: the Go tier includes image and audio models, and Explore / Build and above also include H3 video models. Image and video usage is limited only by the weekly quota and does not count against the 5-hour window — it is the same subscription, with no separate usage-based purchase.

### Editing media: the toolbar sits on the node

Select a node, click a tool to run it, and the result becomes a new node on the canvas. Tools are grouped by who runs them — only the third group consumes quota.

![Select an image node, and the toolbar appears on top of it](https://mintcdn.com/agent-en/V3Bs5jNsIrlVwtOq/images/community/ai-node-canvas/02-toolbar.jpg?fit=max\&auto=format\&n=V3Bs5jNsIrlVwtOq\&q=85\&s=0a3be9cba77d1b4461481b48d20e969f)

| Who runs it | Tools | Cost |
| - | - | - |
| On your machine | Extract frames / grid extract / trim / video crop / auto segment / split audio-video / split audio / merge video / erase subtitles / remove video watermark / remove background / trim audio / smart cutout / sharpen | Free, but ffmpeg must be installed locally |
| Drawn in the page | Grid split / crop | Free, no model involved |
| Vendor-run | Multi-angle / relight / AI cutout / AI upscale / video breakdown / viral-hit analysis | Consumes quota |

![Click Smart cutout: a white-background image becomes a transparent-background image, and the new node is wired after the upstream card](https://mintcdn.com/agent-en/V3Bs5jNsIrlVwtOq/images/community/ai-node-canvas/03-smart-cutout.png?fit=max\&auto=format\&n=V3Bs5jNsIrlVwtOq\&q=85\&s=24e066081f51b55369230685c342df46)

AI cutout and AI upscale are the vendor's own tools: AI cutout separates the subject from a non-solid background and outputs a transparent PNG; AI upscale uses a 2× super-resolution model to sharpen a blurry image. AI upscale has hard limits — long side ≤2048, short side ≥256, file size ≤10MB. Images that exceed the limits are rejected before the request is sent, so you are not charged for a failed call.

Multi-angle and relight have the Agent run on the image: one multi-angle action is multiple runs, and the panel tells you how many runs this action will take before it starts.

### After you have the assets

The generated images and clips are not the end. This section covers what happens after you have the assets: trim, listen, split, and cut out, all directly on the canvas, without exporting and importing again.

![Trimming a video card: the row underneath is frames extracted from the file; drag either end, and the range always stays inside the source](https://mintcdn.com/agent-en/V3Bs5jNsIrlVwtOq/images/community/ai-node-canvas/04-video-trim.png?fit=max\&auto=format\&n=V3Bs5jNsIrlVwtOq\&q=85\&s=f8fe9dcb5179c1122bda980726a27aad)

![Trimming an audio card: a real waveform, with a transport bar underneath for playback, the timecode, and download](https://mintcdn.com/agent-en/V3Bs5jNsIrlVwtOq/images/community/ai-node-canvas/05-audio-trim.png?fit=max\&auto=format\&n=V3Bs5jNsIrlVwtOq\&q=85\&s=936b0bd746b5487e8621bd31769cfc7a)

![Split audio: a tool on the video card that produces its own audio card, with its own transport and waveform](https://mintcdn.com/agent-en/V3Bs5jNsIrlVwtOq/images/community/ai-node-canvas/06-split-audio.png?fit=max\&auto=format\&n=V3Bs5jNsIrlVwtOq\&q=85\&s=b9df253bf037a902f32e8998cf5f0633)

## A real example: from one sentence to an earphone promo

The pipeline below was actually run on a single canvas — from the rough one-liner "a product hero of an Apple Bluetooth earphone" to a roughly 4.5-second 768P final clip, with every step laid out on the canvas.

| Nodes | Connections | Vendor runs | Local tools |
| - | - | - | - |
| 10 | 8 | 7 | 2 |

**01 One sentence → an 8K hero prompt**

In the prompt-enhance node, write "a product hero of an Apple Bluetooth earphone," choose the "Ecommerce hero" format, and the model runs one text pass, filling in five sections: product subject / material detail / scene lighting / composition and camera / quality description.

![Prompt-enhance node: one sentence plus the Ecommerce hero format](https://mintcdn.com/agent-en/V3Bs5jNsIrlVwtOq/images/community/ai-node-canvas/07-prompt-enhance.png?fit=max\&auto=format\&n=V3Bs5jNsIrlVwtOq\&q=85\&s=e21f169ab175cd27452d5ddeffc022cb)

**02 Generate the hero → three angles**

The image node generates from that prompt (MiniMax-H3-Image · 16:9 · 2720×1536). Then click Multi-angle on the node: front, front-left 45°, and front-right 45° each run once, and the three images branch off under the hero.

![Click Multi-angle: one run per angle, three images out](https://mintcdn.com/agent-en/V3Bs5jNsIrlVwtOq/images/community/ai-node-canvas/08-multi-angle.png?fit=max\&auto=format\&n=V3Bs5jNsIrlVwtOq\&q=85\&s=13581ab6d9b306a716ea879b09b15dab)

**03 One anchor image → a six-part storyboard**

Reference the "Multi-angle · front-right 45°" image, choose the "H3 full-reference six-part" format, and use MiniMax-M3: subject definition / summary / reference-preservation analysis / shot-by-shot description / ambient sound / music — 5 shots, with timecode through 00:08.600.

![A six-part storyboard, not a prose paragraph](https://mintcdn.com/agent-en/V3Bs5jNsIrlVwtOq/images/community/ai-node-canvas/09-storyboard.png?fit=max\&auto=format\&n=V3Bs5jNsIrlVwtOq\&q=85\&s=7040b0d2995fb85c706febb91b21e6f9)

**04 Video → split audio → trim to 10 seconds**

Upload a 63-second source video, click Split audio to get an audio-track card, then drag both ends to cut 0:10. That becomes a 10-second audio card, which is connected to the video node as a reference track.

![Click Split audio: the track becomes its own card (1:03)](https://mintcdn.com/agent-en/V3Bs5jNsIrlVwtOq/images/community/ai-node-canvas/10-split-audio-clip.png?fit=max\&auto=format\&n=V3Bs5jNsIrlVwtOq\&q=85\&s=a84a827b8e6419f2589f8285421a4169)

![Drag both ends: a 1:03 track becomes 0:10](https://mintcdn.com/agent-en/V3Bs5jNsIrlVwtOq/images/community/ai-node-canvas/11-audio-trim-10s.png?fit=max\&auto=format\&n=V3Bs5jNsIrlVwtOq\&q=85\&s=ae445468a95d6aaeaa2d45d17d08b8f5)

**05 Reference image + storyboard + audio track → final clip**

Feed all three into MiniMax-H3 (16:9 · 768P · 4s). The result is a roughly 4.5-second · 1344×768 · 24fps final clip with its own audio track.

![After the clip is generated, the node already has Split audio / Trim, so you can keep going](https://mintcdn.com/agent-en/V3Bs5jNsIrlVwtOq/images/community/ai-node-canvas/12-final-video-node.png?fit=max\&auto=format\&n=V3Bs5jNsIrlVwtOq\&q=85\&s=c7625084d4e18504a4f7860fdc76c892)

![First frame of the final clip](https://mintcdn.com/agent-en/V3Bs5jNsIrlVwtOq/images/community/ai-node-canvas/13-final-frame.jpg?fit=max\&auto=format\&n=V3Bs5jNsIrlVwtOq\&q=85\&s=1926ee607cf1b633391776b27dc3a30d)

The original final file is here. It is the output of the video node on the canvas above, with no further editing:

<video src="https://mintcdn.com/agent-en/V3Bs5jNsIrlVwtOq/images/community/ai-node-canvas/earphone-promo.mp4?fit=max&auto=format&n=V3Bs5jNsIrlVwtOq&q=85&s=2a872a8c8bac4e0e0328054d73aaf8eb" controls playsInline>
  AI Node Canvas output: earphone promo final clip
</video>

## What it's good for

| Scenario | Description |
| - | - |
| Images / videos | Multi-step generation means repeatedly tweaking prompts, swapping reference images, and trying aspect ratios. Every step sits on the canvas, and you only rerun the card you change. |
| Product-asset pipeline | Hero → multi-angle → storyboard → audio track → final clip, one chain finished on a single canvas. |
| Reverse someone else's recipe | Connect a video to Video-to-text, or an image to Image-to-text, and read a result you like back into a prompt you can reproduce. |
| Further editing of assets | Trim, extract frames, split audio, cut out a subject, and upscale on the canvas; the output can feed the next step directly. |
| Let the Agent work on it too | The canvas ships 9 MCP tools, so the Agent can add nodes, connect them, apply templates, and start runs on its own. |

## Install

### From the official plugin marketplace

1. In MiniMax Code plugin management, search for "节点画布" (AI Node Canvas).
2. Install and enable it, then restart the client.
3. Tell the Agent "打开节点画布" ("open AI Node Canvas"), or open it from the plugin list.

Version 1.22.9 was merged into the official repository on 2026-11-12; once the marketplace entry syncs, that is the version you get. If your machine is still on an older version (for example 0.86.0), update it in plugin management. To pin a version or change the code yourself, use the source install below.

### Install from source

```text theme={null}
Repository: ai-node-canvas/
Install to: <dataDir>/plugins/ai-node-canvas/
Manifest:   <dataDir>/plugins/ai-node-canvas/.minimax-plugin/plugin.json
```

1. Take the `plugins/antianqi/ai-node-canvas` directory from [MiniMax-AI/MiniMax-Code-MiniApps](https://github.com/MiniMax-AI/MiniMax-Code-MiniApps/tree/main/plugins/antianqi/ai-node-canvas) (the main branch is currently 1.22.9).
2. Copy the entire `ai-node-canvas` directory (including the hidden `.minimax-plugin` folder) into `plugins/ai-node-canvas/` under the MiniMax Code data directory. The default data directory is `~/.minimax`, so the plugin lands at `~/.minimax/plugins/ai-node-canvas/`.
3. Restart MiniMax Code, confirm the plugin is recognized and enabled, then ask the Agent to open AI Node Canvas.

## First run

1. Right-click on a blank canvas and add an Input node; double-click a blank area to place an image node directly.
2. Choose Text, and fill it in with a category template — that text will flow to every downstream node.
3. Select a node: the prompt and parameter row expand below the card, and the toolbar appears above it. Write the prompt, pick the model and parameters, and click Generate — the result lands on this card.
4. Type `@` in the prompt to reference an upstream node's output.
5. Drag the small dot on the right side of a node onto another node to connect them.

From this point on, writing prompts, generating images, generating videos, and editing media all happen in this one window; you do not need to switch out to another app.

Keyboard shortcuts:

| Key | Action |
| - | - |
| Ctrl+Z / Ctrl+Shift+Z / Ctrl+Y | Undo / redo |
| Ctrl+C / Ctrl+V | Copy / paste the selected nodes |
| Delete / Backspace | Delete the selected nodes |
| Shift + drag | Box-select |
| Shift + click | Add a node to, or remove it from, the selection |
| Esc | Close in order: the @ menu → the parameter panel → the context menu → clear the selection |

## The Agent can work on this canvas too

A MiniApp can declare its own MCP endpoints, and this canvas ships them. The host mounts them as built-in capabilities, not as an add-on script. There are 9 tools:

| Tool | What it does |
| - | - |
| `canvas_list` | List canvases |
| `canvas_read` | Read a canvas |
| `canvas_add_node` | Add a node |
| `canvas_connect` | Connect nodes |
| `canvas_update_node` | Change parameters |
| `canvas_list_templates` | List templates |
| `canvas_apply_template` | Apply a template |
| `canvas_remove_node` | Remove a node |
| `canvas_run` | Start a run |

The page always owns storage: the Agent's changes are actions handed to the page to execute, not direct file edits. You drag a connection on the page, the Agent keeps building on the canvas, and both sides see the same document.

## What costs quota

* Applying a template costs nothing; running it is what costs quota.
* Local tools (trim, extract frames, split audio, smart cutout, and so on) and in-page drawing tools (grid split, crop) do not call a model.
* Quota is consumed only when you actually start a model run, or when you use a vendor tool (multi-angle, relight, video breakdown, viral-hit analysis, AI cutout, AI upscale).
* Model coverage follows the M Plan: image and video usage is limited only by the weekly quota and does not count against the 5-hour window — it is the same subscription, with no separate usage-based purchase.

## Data and access

* Connectors are used only for media generation: image, video, speech, and music, and for reading a video back.
* AI cutout and AI upscale are the vendor's own tools, so the image is sent to the vendor for processing — only at the moment you click Apply, and not for any other reason.
* This package only reads its own page resources; it does not read any host files.
* Writes go only to the plugin's own data directory: canvas documents in `canvases/`, working files in `work/`, generated results in `assets/`, and files you bring in in `uploads/`.
* A copy is written to your Downloads folder only when you click Save on a node or in the asset library, and the page tells you where it landed.

## Known limits

* A desktop client that supports MiniApps and Agent turns is required. Whether it can open on the web depends on the app's own responsive layout; the desktop client is the current baseline.
* The 14 local media tools need ffmpeg and ffprobe installed on the machine. If they are missing, the buttons are disabled and the UI explains what is missing; the rest of the app still works.
* Six image tools from the reference product were intentionally left out: collage (it needs several images, not one), poster (the typography came out too rough), watermark removal (you have to draw a box first), clothing recolor (it shifts the background too), lossless resize (it needs numeric input, and crop already does the same job), and ID photo (it only fits ID photos).
* AI upscale limits are shown in the UI: long side ≤2048, short side ≥256, file size ≤10MB.

## FAQ

**Is this a web demo?**

No. It is a MiniMax Code MiniApp plugin: it ships its own client UI, a hosted runtime, and model connectors. Once installed, it is a native app inside mcode, not an add-on script, and not something that asks the Agent to guess where your files are.

**Does a run cost quota?**

Applying a template costs nothing; running it is what costs quota. Local tools and in-page drawing tools do not call a model; quota is consumed only when you actually start a model run or use a vendor tool.

**Can the Agent corrupt my canvas?**

The page always owns storage. The Agent's changes are actions handed to the page to execute, not direct file edits.

**Does it work on a phone?**

AI Node Canvas is a desktop MiniApp. Whether it can open on the web depends on the app's own responsive layout and required capabilities; the desktop client is the current baseline.

**Where are my data and files?**

Canvas documents, assets, and generated results are written in the plugin's own data directory, and nowhere outside the host data directory. A copy is written to Downloads only when you click Save / Save to local.

**Can the same node run twice at once?**

No. A single node cannot run two jobs at the same time, but different nodes can run in parallel — multiple runs can be in flight, each with its own progress log, and each can be cancelled.

**If a run fails halfway, do earlier results disappear?**

No. Each node's output is the card on the canvas. You only rerun the broken path, and earlier results stay where they are.

## Quick reference

| Item | Value |
| - | - |
| Name | 节点画布 · AI Node Canvas |
| Type | Native MiniMax Code MiniApp plugin |
| Author | antianqi |
| Current version | 1.22.9 (merged into the official repository on 2026-11-12) |
| Repository | [MiniMax-AI/MiniMax-Code-MiniApps](https://github.com/MiniMax-AI/MiniMax-Code-MiniApps/tree/main/plugins/antianqi/ai-node-canvas) (official repository, plugin directory `plugins/antianqi/ai-node-canvas`) |
| Install directory | `~/.minimax/plugins/ai-node-canvas/` |
| How to open | Tell the Agent "打开节点画布" ("open AI Node Canvas") |
| Data directory | `~/.minimax` (override with `MINIMAX_DATA_DIR`) |
| MCP tools | 9 |
| Workflow templates | 7 |
| Local tools | 14 (require ffmpeg) |
| Vendor tools | 6 (consume quota) |
| Source and feedback | [MiniMax-Code-MiniApps Issues](https://github.com/MiniMax-AI/MiniMax-Code-MiniApps/issues) |

Questions and suggestions are welcome in the repository's Issues.
