Agent Access

Agent Access lets an MCP client such as Claude Code, Claude Desktop or Codex drive the app: read your project, edit it, run generations, and export.

Both apps work the same way. Each embeds its own MCP server, ships its own bridge binary inside its app bundle, and registers under its own server name, so a client can be connected to both at once and the tools stay apart.

What differs between the two apps

	Cask Film	Cask Flow
Where the switch is	Settings > General > Agent Access	Settings > Agent access
What the switch says	Allow AI agents to control this app via MCP (localhost only)	Allow agent access
Default	On	Off in a released build, on in a development build
Claude Desktop	Connected for you at launch	Connect from Settings
Registered server name	`cask-studio`	`cask-motion`
Bridge inside the bundle	`/Applications/Cask Studio.app/Contents/MacOS/cask-mcp`	`/Applications/Cask Flow.app/Contents/MacOS/cask-mcp`
Handshake directory	`~/Library/Application Support/Cask Studio/agent/`	`~/Library/Application Support/Cask Flow/agent/`
Tools	203, of which 61 only read	76, of which 26 only read

Both server names and both bundle paths still carry the apps’ old product names. They are identifiers rather than labels, and renaming one would break every config already written against it.

What an agent can do

Roughly what you can do by hand, in whichever app it is connected to.

In Cask Film:

Look at the project: what is open, the selection, entity counts, undo depth.
Canvas work: create, move, arrange, rename and delete cards; create region boards and slot cards into them.
Timeline work: add clips, move, trim, split, delete, set transitions, add and reorder clip modifiers.
Library: import files, place them on the canvas or timeline.
Captions: transcribe a clip, fix a misheard line, change how words wrap.
Generation: list models and saved voices, check your balance, estimate a cost, start and poll a job.
Scenes: build a set, place and animate the camera, render test frames and shots, review joins.
Export: start an export and poll its progress.

In Cask Flow:

Look at the project: what is open, the node tree, the camera, the composition.
Scene work: add and update containers, text, images, paths, icons and the pointer; nest them; set the background.
Animation: set and clear keyframes, pick easings, apply presets, stagger a group, move a node along a curve.
Camera: add it, keyframe zoom, centre and rotation, or describe a move.
Audio: import a track, set its gain, set a tempo to cut against.
Checkpoints: snapshot the project and restore one.
Generation and export, the same shape as Cask Film’s.

Both apps let an agent see its work. Tools return an actual picture into the model’s context: a composed frame exactly as export would produce it, a single canvas card in Cask Film, or a contact sheet of up to twelve frames across a range in Cask Flow.

The full, generated tool list for each app ships with that app and is what your client shows you.

What an agent cannot do

Anything, while Agent Access is off.
Anything, while the open project refuses writes. In Cask Film that is a cloud project whose edit lease another Mac holds. In Cask Flow it is a project whose bundle changed on disk under the editor. Either way every write tool refuses and says why.
Sign you in. That is a human action in the app window, and no tool does it. In Cask Flow every tool except the two that report capabilities and guidance is refused while nobody is signed in.
Anything without your client asking you first. See below.
Spend credits invisibly. Generation tools are marked as reaching the backend, and the cost estimate is a separate call from the one that submits.

Every change an agent makes is undoable with your own ⌘Z. Agent edits and your edits share one undo stack.

Your client asks before each tool runs

Approval prompts come from the MCP client, not from the app. The MCP specification tells clients to keep a human in the loop with the ability to deny tool invocations, and a server that could switch that off would be the security hole.

Claude Desktop asks per tool. Claude Code auto-allows read-only tools and asks about the rest. Both let you reduce the asking, and the per-client pages cover how.

Each app’s contribution is making the prompt worth reading. Every tool carries a plain-language title and flags saying whether it only reads, whether it is destructive, whether a retry is safe, and whether it reaches the backend. Your client can then show “Enable or mute a clip” rather than a function name, and can tell a local edit apart from one that spends credits.

That is also why the tool surface is not collapsed into a handful of coarse tools. A batch tool takes an opaque list your client cannot render in a dialog, which makes the prompt least informative exactly when it is authorising the most.

How the connection works

The app serves MCP over HTTP on the loopback interface. Your client does not talk to that directly. It launches cask-mcp, a small bridge shipped inside the app bundle at Contents/MacOS/cask-mcp, which speaks stdio to your client and HTTP to the app.

The bridge exists for two reasons. The app binds a fresh port and mints a fresh token on every launch, so any config naming either would be stale the moment you quit the app. And Claude Desktop’s config cannot describe an HTTP server at all. The bridge re-reads the app’s handshake on every request, so its config names nothing that can go stale, and you never handle a token.

The bridge answers the client’s handshake itself, so registering the server works whether or not the app is running. With the app closed, the tool list is empty rather than broken, and the tools appear on their own when you open the app. You do not have to restart your client.

Nothing else on your network can reach the server. It answers no cross-origin headers, so a web page cannot make requests to it either.

Set it up

Turn on Agent Access (Cask Film has it on already)
Connect your client: Claude Code, Claude Desktop, Codex, or any other MCP client
If something is wrong, see Fix an agent connection