Caddis gives visual agents two controls they need: render and undo
An agent calls a tool and gets a success response. In many demos, that is where the work ends. Visual software makes the weakness of that stopping rule obvious. A node may accept a value, a shader may compile, and the requested keyframes may exist while the finished frame still looks wrong.
Caddis 1.0.4, released August 26, adds an opt-in local MCP server to an independent motion-design application. Agents can build node graphs, animate parameters, draw vector paths, and write shaders in an open project. Two less glamorous capabilities make those edits reviewable. Agents can render frames to inspect what they made, and every action reaches the application as one undo step.
This pattern belongs in any creative tool that exposes editing to agents. After a change, the agent needs access to the artifact people will judge. The person watching needs a quick route back to the last good state.
Tool success does not tell you whether the frame works
The Caddis 1.0.4 release notes describe what agents may edit. They can create and connect nodes, adjust parameters, add keyframes, reorder layers, manage compositions, import media, draw SVG paths, and change gradient or curve ramps. Shader nodes accept WGSL or Shadertoy-style GLSL. Caddis compiles shader code before applying it and sends line-mapped errors back to the agent when compilation fails.
Compilation and parameter validation catch structural errors. They cannot tell whether a title enters too slowly, a glow hides the subject, or a vertical crop loses the important motion. The project may be valid while the image is bad.
The Agent Access documentation exposes rendering for that reason. Agents may request any frame at draft, preview, or full quality. In the documented example, the agent builds a layer, renders a frame, and iterates while the user watches the viewport.
A coding agent edits a file and then runs tests. The visual equivalent is to edit the project graph and inspect a render. In both cases, the editable representation is not the judged result.
One action, one undo step
Every Caddis agent action is grouped into a single undo step. One Cmd+Z reverses it, just like a human edit.
Creative applications can hide many connected mutations behind a visible change. Adding a styled layer may create nodes, ports, parameters, and timeline entries. If an agent delivers those mutations as a loose stream, users cannot easily keep the useful part and remove the rest. An undo unit tied to each action gives the review a shape.
The action still has to be sensibly sized. “Rebuild the whole composition” could create one enormous rollback unit. Smaller stages are easier to judge:
- Create the layer and its base shape.
- Render the target frame.
- Add animation, then render its start, midpoint, and end.
- Apply the effect stack and render again.
- Duplicate the composition for another aspect ratio.
Each stage now has a visible result and a recovery point. The user can keep the useful work and reverse the first bad action. This resembles the reviewable-result pattern in our guide to agent tool interface design, with image evidence added to the structured tool response.
The endpoint is local, and the client still matters
Agent Access is disabled by default. Enabling it starts a configurable Streamable HTTP endpoint at http://127.0.0.1:4923/mcp. Caddis says the server listens only on the local machine, validates request origins, and closes as soon as the toggle is disabled or the application quits.
The MCP transport specification requires Origin validation for Streamable HTTP, advises local servers to bind to localhost, and recommends proper authentication for all connections. Its warning is specific: without these protections, a remote website could use DNS rebinding to interact with a local MCP server.
Caddis documents loopback binding and Origin validation. Its public Agent Access page does not describe per-client authentication or tool-level permission scopes. Connect MCP clients you control, and do not use “local” as a complete permission model. A creative application deserves the same least-privilege review as a repository or shell tool.
Some authority remains explicitly human in version 1. Agents edit the frontmost open project, while people still open and save project files. Only one Caddis window is supported at a time. Tracking data, per-point shape edits, and styled text runs are visible to an agent in summary form but are not editable.
“Works inside the app” therefore has a defined boundary. The user selects the project, the agent edits its active composition, and the user chooses what to save.
Use the renderer as a visual test harness
The official Caddis product page describes a timeline-based, node-driven editor with GPU-native rendering. Agent Access is best used as a visual test loop, with bounded edits and images that can be checked.
- Inspect composition size, frame rate, duration, layer order, and the relevant node graph before editing.
- Request one bounded change and include a visual acceptance condition, such as keeping the subject inside a 9:16 safe area.
- Render representative frames rather than only the current playhead.
- Compare each image with the acceptance condition and correct one defect at a time.
- Stop before saving so the user can inspect the viewport and undo history.
Animation has a problem that a still image does not. A clean midpoint says nothing about whether the entrance begins off-screen, the easing reads well, or the final frame settles. Render the start, at least one transition frame, and the end. Add checks around collisions, cuts, and effect changes when the motion is more complex.
Keep the rendered evidence with the session record. Store the frame number, composition dimensions, render quality, and the instruction that produced the edit. A transcript that only says the render tool returned successfully is too weak for later review. Our guide to trajectory-level agent evaluation makes the same point for code: checkpoints and the path between them matter.
Make the rollback match the review
Caddis does not claim that an agent has artistic judgment, and its release notes offer no benchmark for design quality. It does show how judgment can fit inside the workflow. An agent reads structured state, changes it, renders the consequence, and revises. The user watches and can reverse each action.
For every bounded edit, render the frames that could prove it wrong. Keep that edit inside one undo unit until those frames pass review.
