MCP server

Shoot Plan

uk.co.theamateur/shoot-plan

Checked 28 Oct 2026, 09:03 UTC · Connected to it and listed its tools

Practical filming plans for AI assistants, with tools to draft, check and export shot plans.

Website

At a glance

Type

MCP server

Publisher

theamateur.co.uk (verified by the MCP Registry)

Status

Working at last check

Tools

34

Token cost

About 16,582 tokens per request

Sets up in

Claude Code, Claude Desktop, Codex, Gemini CLI, Cursor, VS Code, Antigravity, ChatGPT, OpenAI API, Grok

Last checked

28 Oct 2026, 09:03 UTC

Connect it to your agent

Add to CursorAdd to VS CodeVS Code Insiders

Opens the app, which shows the server and asks you to confirm. For other apps, copy the setup below.

Claude Code

claude mcp add --transport http shoot-plan https://theamateur.co.uk/mcp/shoot-plan

Claude Desktop

Settings → Connectors → Add custom connector, and paste the URL.

Codex (config.toml)

[mcp_servers.shoot-plan]
url = "https://theamateur.co.uk/mcp/shoot-plan"

Gemini CLI

{"mcpServers":{"shoot-plan":{"httpUrl":"https://theamateur.co.uk/mcp/shoot-plan"}}}

Cursor

{"mcpServers":{"shoot-plan":{"url":"https://theamateur.co.uk/mcp/shoot-plan"}}}

VS Code

{"servers":{"shoot-plan":{"type":"http","url":"https://theamateur.co.uk/mcp/shoot-plan"}}}

Antigravity

agy mcp add shoot-plan https://theamateur.co.uk/mcp/shoot-plan

ChatGPT

Settings → Apps & Connectors → Advanced settings: turn on Developer mode, then Create a connector and paste the URL. Which plans can do this varies.

OpenAI API (Responses tools)

{"type":"mcp","server_label":"shoot-plan","server_url":"https://theamateur.co.uk/mcp/shoot-plan","require_approval":"always"}

Grok (xAI API tools)

{"type":"mcp","server_label":"shoot-plan","server_url":"https://theamateur.co.uk/mcp/shoot-plan"}

Tools

• shoot_plan_allowance ~383 tokens
  Says what this account has used and has left of its monthly project allowance, the date it starts again, and, when the limit is reached, how to carry on sooner. A project is identified by the plan's work id and title: the same id and title is one project, and changing either starts a new one. It cou
• shoot_plan_apply_fix ~457 tokens
  Applies one fix, taken from a shoot_plan_check result, to a plan and checks the revised plan again. Some fixes trade one thing for another (each says its trade_off): tell your human before applying one that does. Input: plan; finding_id and fix_id (a finding's id, and the id of one of its suggestion
• shoot_plan_call_sheet ~500 tokens
  Makes the call sheet for a shoot from a plan's schedule: for the whole schedule, or for one shoot day, who is called, where and when, with the set-ups in order. A plan with no schedule has no times, and the call sheet says so rather than inventing any. Input: plan, a dpl.plan/1 object that validates
• shoot_plan_capabilities ~59 tokens
  Return truthful Shoot Plan scope, availability, privacy and commercial state.
• shoot_plan_check ~640 tokens
  Checks whether a shot plan will cut together before you film or generate it. It looks for crossed lines of action, mismatched eyelines, missing reactions, speakers who are never on screen, missing geography, jump cuts, travel direction, and props that change with no cause. It returns evidence from t
• shoot_plan_coverage_status ~627 tokens
  Answers "did we get it?" before the crew leaves a location: from the plan and the take log it says which must-have shots have no good take, which reactions or cutaways the edit will need are still missing, what must match on the next set-up, and whether room tone was recorded. A "hold" verdict is no
• shoot_plan_create ~1834 tokens
  Create a plan for an authenticated organisation after authoritative payment confirmation.
• shoot_plan_diff ~560 tokens
  Says what changed between two versions of a plan, so that you can catch up from a few lines instead of reading both. It compares by id, not by position, so reordering changes nothing: it lists what was added, what was removed, what changed (with the old and new values), and an id that has gone while
• shoot_plan_draft_gate ~400 tokens
  The final check on a drafted plan: is it finished and ready to shoot? It returns ready or not ready, with a record of what was checked and what was not. A plan that does not pass gets a normal answer, not an error: the reasons are the next actions, each with its plan path and a fix. A pass is the re
• shoot_plan_draft_next ~574 tokens
  Says where a draft stands and the one next thing to do, so you can write a plan layer by layer and have each layer checked as you go. It reads the plan you send and never changes it. It returns the layer you have reached, what that layer still lacks as exact plan paths, the questions to put to your
• shoot_plan_draft_start ~514 tokens
  Starts a shot plan for you to write: from a short brief it returns a valid skeleton plan (the places to write start with TODO), the layers to write it in, shot-pattern recipes for common kinds of scene, and the first thing to do. The loop is: you write the plan, we check it. We write none of the fil
• shoot_plan_edit_guide ~568 tokens
  Writes the editing guide for a film, scene by scene: what each shot is for, where to cut and why, which cutaway or insert covers which jump or crossed line, the sound to lay, and each open finding as a note about what to do in the edit. With a take log it also says which take stands for each shot an
• shoot_plan_example ~60 tokens
  Return a synthetic example plan generated by the real planner, with its provenance.
• shoot_plan_export_edit ~866 tokens
  Makes a first assembly edit from the plan and the take log, as a file your own editing software opens: OpenTimelineIO (otio), FCPXML (fcpxml), a CMX 3600 edit decision list (edl) or an ALE log (ale). It puts the chosen takes in story order, each as long as the plan's slot (a shot with no usable take
• shoot_plan_export_for_generation ~623 tokens
  Prepares a plan for generating its pictures with a generator of your own: it returns the editorial intent of the film (eil.intent/1) and one generation brief per shot (eil.generation-briefs/1). We run no generator and receive no media: you give the briefs to your own. Input: plan; optional sequence
• shoot_plan_fit_to_budget ~446 tokens
  Cuts a plan down to what the shoot can afford, without dropping a shot marked `must`: it takes out the least necessary shots one at a time, re-checking the plan after each, and tells you what each cut costs. Input: plan, and constraints: max_shots (the most shots the cut may need) and/or max_setups
• shoot_plan_format ~240 tokens
  Returns what you need to write or repair a plan that the checks can read: links to the JSON Schemas, the shortest valid plan, a worked example of a two-person scene that the checks find nothing wrong with, and a summary of the details that switch each check on (which is why a thin plan comes back "n
• shoot_plan_get ~228 tokens
  Return a full plan: shots in filming order (priority must = essential), setup groups per location or visit, checklist, coverage risks, progress (item keys already ticked), progressSummary with counts, each tick's time and source (web, field or agent), and timeSummary when the plan has timing. Struct
• shoot_plan_list ~146 tokens
  List the authenticated organisation's Shoot Plans, most recently changed first, without returning private intake or full plan content. Archived plans are left out unless includeArchived is true. Each plan's taskId is the ID every other plan tool takes. Structured result: {plans:[...]}.
• shoot_plan_merge_takes ~410 tokens
  Joins two take logs for the same film into one, for when two phones, an AI assistant and a script supervisor each kept a log while offline. Joining is by op_id, so a take that is in both logs counts once and merging again changes nothing. Where two logs hold different takes under one op_id, only one
• shoot_plan_missing_details ~303 tokens
  Lists the questions to put to the person who knows the film, so that more of the plan can be checked. Each question uses the plan's own names, says which paths in the plan the answer fills in and which checks it unlocks, and says whether it blocks the assessment of a scene. Do not invent an answer t
• shoot_plan_progress_sync ~382 tokens
  Tick or untick shots and checklist items. Each op: itemKey "shot:<shotId>" or "check:<itemId>" from shoot_plan_get, basePlanVersion = the plan's version, a new random UUID v4 as opId, state "complete" or "incomplete". Retry-safe: resending the same opId does nothing twice. An op made against an olde
• shoot_plan_quote ~412 tokens
  Calculate a deterministic public quote from non-private project metadata. Do not send a script or brief.
• shoot_plan_record_decision ~729 tokens
  Records a decision about one finding from shoot_plan_check (accepted, overridden or wont_fix), with the reason and who decided, so that you do not raise it again next session. We keep nothing: the answer is the updated decision log, and you must keep it and send it back to shoot_plan_check as dispos
• shoot_plan_revise ~649 tokens
  Use the plan's one included revision. This cannot be undone and uses up that revision, so call shoot_plan_revision_preview first and confirm with the person. For structured plans, change filming time or transfer time (constraintUpdates.availableMinutes, locationTransferMinutes), framing, or structur
• shoot_plan_revision_preview ~610 tokens
  Structured plans only; older free-text plans cannot be previewed. Preview a revision without using it: what would change, which checked shots would be cleared, and whether it still fits. For example constraintUpdates.availableMinutes: 30 answers "what if I only had 30 minutes?". Never uses the inclu
• shoot_plan_shoot_pack ~500 tokens
  Makes the pack to take on the shoot day: the call sheet with, for each scene, its shots, the action, the look and the sound notes. Use it when the crew needs one document to work from; use shoot_plan_call_sheet when only the times and people are wanted. Input: plan, a dpl.plan/1 object that validate
• shoot_plan_shot_list ~460 tokens
  Turns a plan into a shot list a crew can work from. Input: plan; format, "json" (default, dpl.shot-list/1) or "markdown"; vocabulary, an optional industry vocabulary for camera terms (for example "movielabs@1.0"). Output: the shot list, or {format:"markdown", markdown}. No AI model runs. We don't ke
• shoot_plan_slice ~566 tokens
  Cuts out part of a plan, so that you can send a smaller plan when your context is short: the scenes, the shots or the sequence you name, with everything they refer to (characters, places, props, sound and the rest) and their times unchanged. The slice is a valid plan of its own, so you can send it t
• shoot_plan_status ~157 tokens
  Return a plan's status, version, whether its included revision is used, its customer-facing order reference, and progress (essential shots ticked, next shot, when the last tick was made). Read-only. Use the full taskId from shoot_plan_list (not planId). A unique eight-character task prefix or orderR
• shoot_plan_summary ~484 tokens
  Gives a short account of a plan, about 300 words, so that you can pick the work up again without being sent the whole plan: the title, the planned runtime against the target, the counts of scenes, shots, characters and places, the thesis and journey, one line for each sequence and scene, the missing
• shoot_plan_timing ~188 tokens
  Structured plans only (not older free-text plans). Compare planned and actual filming time between consecutive ticks in field mode. plannedSeconds is the planned time of those measured tick-to-tick steps, not the whole plan; planPlannedSeconds is the whole plan's planned shot work when present. Read
• shoot_plan_to_dpl ~556 tokens
  Converts one of your organisation's purchased Shoot Plan plans into a dpl.plan/1 plan in the short-form profile, so you can pass it to shoot_plan_check. It is the same conversion dpl-eil's reference importer makes, and it is one way only. Input: planId (the plan's planId, spp_..., as shown inside sh
• shoot_plan_validate_takes ~451 tokens
  Checks a log of takes against the plan it was shot from, before you rely on it. It finds shots that are not in the plan, take numbers used twice, one op_id used for two different takes, file names written as paths, and a log made for another film or another revision of the plan. Each problem has a p

Browse

• Website monitoring
• Payments
• Travel and flights
• Food and recipes

Related MCP servers

• Gravitate
  Free bilingual dating guides, fictional profile examples, photo plans and observation scoring.
• mcp.film directory
  Search the curated directory of MCP servers for AI filmmaking and plan a full production stack.
• Calcfleet Calculators
  Tested financial & practical calculators as free, no-auth MCP tools for AI agents.
• oriiion
  Your marketing, a message away
• SMI Aware Assistant
  Remote MCP server exposing SMI Aware tools, resources, and skills over Streamable HTTP.
• Instavar Video Templates and Studio
  Free Remotion video templates and creative guides; optional hosted Studio rendering and publishing.
• FilmLab
  AI film lab for filmmakers: generate and review images/clips with input provenance, cost preflight
• Uwear
  AI photoshoot studio: garments, avatars, locations, and art direction

Badge for your README

[![AptLynx](https://aptlynx.net/badge/uk.co.theamateur/shoot-plan.svg)](https://aptlynx.net/servers/uk.co.theamateur/shoot-plan)

Listing text is written by the maker; AptLynx lists tools and does not vouch for them. Find another tool · Browse by topic · For agents