Cavalry MCP Bridge
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Cavalry MCP Bridge create a pulsating circle with a duplicator and connect a noise node to its scale"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
# Cavalry Motion App MCP Bridge
A Model Context Protocol (MCP) server that connects AI assistants (like Claude Desktop, Antigravity, Cursor, and ChatGPT) directly to Cavalry, the procedural 2D motion graphics and animation application by Scene Group.
Features
Procedural Layer Creation: Create shapes, text, duplicators, grids, noise generators, color palettes, math nodes, deformers, and particle emitters via natural language.
Dynamic Node Graph Connections: Connect outputs and inputs between nodes (e.g. wire a noise generator to a shape's scale or rotation).
Attribute Control & Keyframing: Inspect and update any property, scrub the timeline, and add animated keyframes.
Scene Introspection: Query active composition metadata, layer hierarchies, and selected nodes.
Render Pipeline: Add compositions to the Render Queue and trigger batch renders.
Raw Script Execution: Execute arbitrary JavaScript against Cavalry’s native
api.*module.
Related MCP server: cavalry-mcp
Architecture
┌─────────────────────────┐ stdio (MCP) ┌─────────────────────────────────┐
│ AI Assistant / LLM │ ◄──────────────────────────► │ Cavalry MCP Server │
│ (Claude, Antigravity) │ │ (TypeScript / Node.js) │
└─────────────────────────┘ └────────────────┬────────────────┘
│
HTTP POST │ (http://127.0.0.1:8080)
▼
┌─────────────────────────────────┐
│ In-Cavalry Script Bridge │
│ (MCPBridge.js in Scripts menu) │
│ ───► api.create(...) │
│ ───► api.set(...) │
│ ───► api.connect(...) │
└─────────────────────────────────┘Quick Start
1. Install Dependencies & Build
From this project directory:
npm install
npm run build2. Install Bridge Script into Cavalry
Run the installer to copy MCPBridge.js to your Cavalry scripts folder:
npm run install-bridgeOn Windows, this copies MCPBridge.js to %APPDATA%\Cavalry\Scripts\.
3. Start the Bridge in Cavalry
Launch Cavalry.
Go to the top menu: Scripts → MCPBridge.
A small panel will open showing
Status: Online (Port 8080). Keep this open while using the MCP server.
(Alternatively, if you already have the Stallion extension active, it also listens on port 8080 and works seamlessly with this MCP server).
4. Test the Connection
Verify that the MCP server can communicate with Cavalry:
npm run test-connectionMCP Client Configuration
Claude Desktop
Add the following to your claude_desktop_config.json (located at %APPDATA%\Claude\claude_desktop_config.json on Windows or ~/Library/Application Support/Claude/claude_desktop_config.json on macOS):
{
"mcpServers": {
"cavalry": {
"command": "node",
"args": [
"C:/Users/david/Documents/ANTIGRAVITY APP/CALVARY MCP/dist/index.js"
],
"env": {
"CAVALRY_BRIDGE_PORT": "8080"
}
}
}
}Antigravity / Cursor / Custom Client
Add to your settings or .cursor/mcp.json:
{
"mcpServers": {
"cavalry": {
"command": "node",
"args": ["C:/Users/david/Documents/ANTIGRAVITY APP/CALVARY MCP/dist/index.js"]
}
}
}Available MCP Tools
Tool | Description |
| Run arbitrary JavaScript code in Cavalry using |
| Evaluate a single expression and return its value. |
| Query active composition name, frame count, FPS, and layer count. |
| List all layer IDs in the current composition. |
| Get the IDs of currently selected layers. |
| Create a new layer/node ( |
| Set one or more attribute values on a layer. |
| Query an attribute value on a layer. |
| Delete a layer/node from the scene. |
| Connect source attribute to target attribute in dependency graph. |
| Disconnect an attribute connection. |
| Scrub the playhead to a specific frame. |
| Get the current frame number. |
| Add a keyframe with value at a specified frame. |
| Play, stop, or rewind the timeline. |
| Add the composition to the Render Manager. |
| Start rendering items in the queue. |
Example Prompts for AI Assistants
1. Animated Noise Grid
"Create a 12x12 grid of rounded squares in Cavalry, attach a noise modifier to their rotation and scale, and set the fill color to electric blue."
2. Kinetic Typography
"Create kinetic text with the headline 'ANTIGRAVITY' in Cavalry. Set the font size to 120, center it, and add a bouncy spring oscillation to the Y position."
3. Radial Burst Animation
"Build a radial burst animation with 24 lines radiating outwards from the center, driven by a step duplicator and keyed to expand from frame 0 to frame 45."
License
MIT
Available Tools
18 toolscavalry_add_to_render_queueB
Adds the active composition to the Cavalry Render Queue with specified format or destination.
Inputs: format, outputPath.
cavalry_connect_attributesA
Connects an attribute or output of a source node to an input attribute of a target node in Cavalry's procedural dependency graph.
Inputs: sourceId (required), targetId (required), sourceAttr (required), targetAttr (required).
cavalry_create_layerA
Creates a new layer or procedural node in the active Cavalry scene (e.g. 'basicShape', 'textShape', 'duplicator', 'gridDistribution', 'noise', 'colorArray', 'nullLayer', 'particleEmitter', 'deformer').
Inputs: name (required), type (required), attributes.
cavalry_create_primitiveB
Creates a geometric primitive shape in Cavalry (e.g. 'ellipse', 'rectangle', 'star', 'superEllipse', 'polygon', 'ring', 'arrow', 'line') with optional initial attributes like 'material.materialColor', 'scale.x', 'scale.y', 'position.x', 'position.y'.
Inputs: name (required), generator (required), attributes.
cavalry_delete_layerC
Deletes a layer or node from the scene.
Inputs: layerId (required).
cavalry_disconnect_attributesB
Breaks a connection to a specific attribute on a target node in Cavalry.
Inputs: targetId (required), targetAttr (required), sourceId, sourceAttr.
cavalry_eval_expressionB
Evaluates a single JavaScript expression inside Cavalry and returns its value.
Inputs: expression (required).
cavalry_get_attributesB
Retrieves the value of a specific attribute or array of attributes from a layer.
Inputs: layerId (required), attributePath (required).
cavalry_get_comp_layersB
Returns an array of layer and node IDs present in the active composition.
Inputs: topLevelOnly.
cavalry_get_frameA
Returns the current playhead frame number in the active composition.
Inputs: no named parameters.
cavalry_get_scene_infoA
Retrieves metadata about the active Cavalry composition, including current frame, total duration, frame rate, and layer hierarchy.
Inputs: no named parameters.
cavalry_get_selected_layersB
Returns an array of IDs of the currently selected layers in the Cavalry viewport / scene tree.
Inputs: no named parameters.
cavalry_playback_controlA
Controls timeline playback (play, stop, or rewind) in the active viewport.
Inputs: action (required).
cavalry_render_queueA
Triggers rendering of the items in the Render Manager / Render Queue.
Inputs: no named parameters.
cavalry_run_scriptA
Executes a multiline JavaScript automation script inside Cavalry using the api.* module. Use this for complex procedural generation, node network creation, and batch updates.
Inputs: code (required).
cavalry_set_attributesB
Sets one or more attribute values on an existing layer in Cavalry (e.g. 'material.materialColor', 'position.x', 'scale.x', 'rotation.z', 'opacity').
Inputs: layerId (required), attributes (required).
cavalry_set_frameA
Moves the timeline playhead to a specific frame number in the active composition.
Inputs: frame (required).
cavalry_set_keyframeA
Sets an animation keyframe for attributes on a layer at a given frame number using Cavalry's official api.keyframe(layerId, frame, { attr: value }) API.
Inputs: frame (required), layerId (required), attributes (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 18 tools
Most tools target clearly distinct operations: creation, attribute access, graph connections, timeline, playback, and rendering. However, `eval_expression` and `run_script` overlap in JS execution, and `render_queue` vs `add_to_render_queue` could cause minor confusion despite different purposes.
All tools share the `cavalry_` prefix and mostly follow a verb_noun pattern such as `get_scene_info`, `create_layer`, and `set_attributes`. Minor deviations like `playback_control` and `add_to_render_queue` break the strict pattern but do not harm readability.
Eighteen tools is on the heavier side and the count falls in the 16-25 borderline range. The breadth is understandable for a motion-graphics automation bridge, but a few tools could be consolidated, such as merging `get_comp_layers` and `get_selected_layers` or `render_queue` and `add_to_render_queue`.
The toolset covers the main workflows: scene inspection, layer creation, attribute manipulation, graph connections, animation keyframing, timeline control, and rendering. Obvious gaps like composition management or render queue status checking are missing, but the core lifecycle is well represented for the stated purpose.
Maintenance
Related MCP Connectors
One sentence to a finished animation: your AI writes motion graphics as code and checks real frames.
Video production studio for AI agents: AI media, motion graphics as code, timeline and export.
Build and run visual creative-production workflows from your AI agent.
The agentic video editor for ChatGPT and Claude. Ask in your chat and it cuts, captions, adds music, titles and motion graphics on a real timeline you can open and adjust.
Related MCP Servers
- AlicenseAqualityCmaintenanceEnables natural language control of Cavalry animation software for creating layers, setting attributes, keyframing, rendering frames, and more via an MCP server.2131MIT
- FlicenseBqualityDmaintenanceMCP server for driving Cavalry's 2D motion-graphics engine from LLMs, enabling scene creation and animation via natural language.283-
- AlicenseAqualityBmaintenanceEnables AI assistants to operate Adobe After Effects with the dexterity of an editor: reading projects, creating and rigging layers, setting real velocity curves, animating text, building native SVG-based shapes, applying effects, expressions, masks, and viewing render snapshots to verify results.1718 npm1MIT
- AlicenseNot gradedqualityCmaintenanceEnables Claude to inspect and edit Cavalry scenes by reading layers and connections, executing JavaScript, connecting nodes, changing Duplicator distributions, and rendering frames for visual feedback.MIT