List Takes projects and how many sessions each has. Start here.

Create a project (a folder in the Takes library).

List sessions in a project, newest first, with take and keeper counts.

Get a session: its id, title, full script, and every take with file path, duration, keeper flag, name and start time (camera and screen files of one take share a number), plus every asset file (edits/, thumbnails/, stills/, assets/), the folder rules ('folders') and 'warnings' about files in the wrong place: fix those. Each take shows edit_ready (word times are ready). Cut takes with cut_take and rough_cut by default: they fix the audio offset and frame rate. checks: the check_edit state of each newest edit. rules: the rules for the session's next step that this chat has not seen yet; follow them.

Create a recording session with a title and the script to read on the teleprompter, optionally with variants. Offers it in the Takes app unless open=false (see open_in_app).

Change a session's title (renames its folder) and/or replace its main script. Script changes are saved to history on both sides, so they can be undone. Give a short note. After a rename, use the returned path or the session id; the old path still works.

Offer several hooks (opening lines) for a session. Replaces earlier hook options. The app shows them above the teleprompter; picking one puts it in the script's first paragraph (the hook slot), and each take records which hook it opened with (take field 'hook'). Write script.md with your best hook as its own first paragraph. Use this for hook options; use variants for different whole scripts.

Write the session's storyboard: the video as a row of shots that the user sees as a horizontal timeline of sketches on the Storyboard tab, each with its script lines. Use it with the storyboard skill when the user brainstorms a video idea. Replaces the earlier storyboard. Each shot covers one or two script paragraphs: 'say' is those lines word for word from script.md, 'do' is how to film or build it in one short line, 'sketch' is what the frame shows (people, props, framing, the camera move or the motion as arrows; never text in the frame). A sketch already drawn is kept; a new or changed sketch is drawn in the background, about 30 s. redraw=true draws a shot again with the same sketch text. With no image key, nothing is drawn and the answer says so: ask the user for a key, or pass your own sketch as the shot's 'image'. 'video' puts a real clip on the shot instead of a sketch (a file from list_broll, or a file in the session such as edits/x.mp4 or a still such as generated/x.png); the app shows its frame and plays it on hover. 'variants' puts several clips or stills on one shot (A, B, C... in that order) for the user to choose from: the shot shows as a stack; the user flips through them and picks one; 'video' is the one in the video (default the first). Left out, the shot keeps its variants. A new Higgsfield or Replicate clip for a shot keeps the old one as a variant. The user records takes per shot and comments on shots: get_session's 'storyboard' lists each shot's id, section, takes and open comments. 'format' is the video's shape: the cards and sketches use it.

Write the session's post for LinkedIn (default, posts/linkedin.md) or X (platform=x, posts/x.md). One session holds one post per platform, so the LinkedIn post and its X version sit together. LinkedIn: the app shows a real LinkedIn feed post with the video, cut after three lines with '…more', so put the hook in the first two lines. Max 3000 characters. X: the app shows a real X post, or a thread when you pass several tweets (tweets=[...], or text with a line holding only '---' between tweets). The media goes on the first tweet. The timeline cuts a tweet over 280 characters with 'Show more' (the user has Premium, so longer is allowed). The user edits the post in the app and comments on selected text; fix those comments with set_post. YouTube (platform=youtube): the long wide video. Pass title (max 100) and the description as text (chapters as '0:00 Intro' lines). Vertical (platform=vertical, also for tiktok/reels/shorts): one caption for TikTok, Instagram Reels and YouTube Shorts with the 9:16 edit; hook in the first line, max 2200 characters, at most 5 hashtags; title is the Shorts title, on picks the places. The old text stays in history. get_session returns them as 'post', 'x_post', 'youtube_post', 'vertical_post'. Posts are plain text only: they show no markdown. No video? The post works without one (text only, or pass an image). For other versions use create_post_variants; for opening options set_post_hooks. With variant= it edits that variant instead of the main post.

Add other versions of the session's LinkedIn or X post (e.g. 'Story first', 'Shorter', 'Single tweet'). The app shows them as tabs above the post preview; the user compares, edits, comments and picks one with 'Use as main'. Only the main post is scheduled. Write the main post with set_post first. Edit a variant later with set_post variant=. For different openings of the same post use set_post_hooks.

Write the session's slides (posts/carousel.json), one set for both posts: the LinkedIn post can show them as a document (PDF) and the vertical post as photos (TikTok, Instagram) in place of the video. Slides replace the old ones. The post text stays in set_post. A carousel is not only text: pick a layout per slide and use the session's own pictures (stills/, storyboard/ sketches, thumbnails/, a frame of a take or an edit with at). Mix them: a cover photo, one big word, frames with tags, before and after, a photo with notes, a magazine page, a short video. For 'how I filmed this': a cover, frames of the storyboard sketches, then a compare per shot (the sketch, then the take at its best cut). For 'how I built it' (look desk): a text hook, a list of the steps, one screen slide per step with its screen take (take-NN-screen.mov, start/end at its best cut), a text ask. Put the key words of a title in stars: they take the accent colour.

Make a post variant the main post (the one that is scheduled). The old main goes to post history and the variant tab closes. Only when the user asks; the user usually does it in the app.

Move post variants to the macOS Trash (their text stays in post history).

Offer several hooks for the LinkedIn or X post: opening lines (LinkedIn: the part above '…more', about two lines; X: the first tweet's opening). Replaces earlier hooks for that platform. The app lists them above the post; picking one replaces the post's first paragraph. Write the post with your best hook as its own first paragraph.

Every saved version of the post and its variants, newest first: version, draft ('main' or a variant slug), author (user or claude), note, created, preview. Pass version to get its full text, e.g. to compare with the current post. A version is saved on every change by Claude and while the user edits.

Put an old version back (into its variant if it still exists, else the main post). The current text is saved to history first.

The posting plan: every LinkedIn and X post the user marked ready or that is scheduled, across all projects, sorted by time. Each has platform, session, title, text (X: also 'tweets'), media_path (the video to upload), status, at (iso, utc, local in the chosen tz, this_mac = the Mac's zone, which LinkedIn's scheduler uses) and 'action': what to do on that platform now (schedule, move, replace text, delete, or nothing). The user sets the times with [schedule] on the post tab, or asks you to pick them.

The user's posting plan: the weekdays to post, the slots in the next 14 days, which are empty (next_gap), the buffer (covered slots before the first empty one) and ready posts with no time yet. Use it to tie a new take or edit to the slot it can fill, and to suggest a time when the user marks a post ready. No plan yet: ask the user which days, then set_plan.

Save the posting days the user picked. Overwrites the plan. Returns get_plan.

Put a session's video card on a day of the user's Plan board (the calendar in Takes), move it to another day, or take it off (day empty). Use it when the user asks you to plan videos; one call per video. A card shows the session's title and thumbnail; the user drags cards to reorder them. A card covers that day's posting slot as planned; a post with a time fills it. The board grows to show the card's week. Returns get_plan.

Record what you did on LinkedIn or X (platform=x) for a session's post. status=scheduled after you scheduled it (records the time and text you scheduled, so later changes show up as an action); status=posted with url once it is live (also marks the session published); ready to undo. The user marks posts ready in the app; only set ready or draft when asked. A post you were asked to schedule that has no time: pass at, the time you picked on the platform.

The user's review comments in a session or a library (pass library, not session). Video: 'when' (start/end s), an optional rect (x,y,w,h fractions from top left) and a 'frame' PNG with the area outlined in orange: read it to see what the comment means; 'said' quotes the words spoken then (from the video's transcript). Image: rect + frame. Text (script, variant, README.md, tokens.json): 'quote' is the selected text. Default: open comments.

Reply to review comments and resolve them. After a round of fixes, send ONE call with replies=[{id, text, resolve, fixed_in, fixed_at, lesson}] for every comment. fixed_in: the new version's file; fixed_at: the second in it where the fix shows (a click on the reply jumps there). text: one line ('Caption 20% smaller'). Unclear comment: ask a question, resolve omitted. In a session each resolved comment needs a lesson: a rule id from get_rules, with missed=true when the edit broke that rule (the same mistake again) or missed=false for a new ask or taste near it; 'new' with rule={area, text} (it applies to the next videos too); else 'one-off'.

The rules learned from the user's comments, one file per step: plan (storyboard, script), make (sound, cut, picture, captions, graphics), package (thumbnail), publish (post-all, post-linkedin, post-x, post-youtube, post-vertical), engage (comments) and other. Read and follow the steps you work on before you write, edit or design. get_session and next_path show new ones once per chat; a write tool shows unseen ones once. Without area: the steps with rule counts (full=true at 10).

Add, change, turn off or remove one learned rule. text is one sentence (at most 220 characters); put the rest in details. Keep each area small (10 rules): sharpen a rule before you add one. When an area is full, add the new rule with merge_into (the closest rule) and merged (one sentence for both): The user approves the merge on the Feedback board. Both rules are on until the user decides. Never change a rule the user wrote (by_user) without asking first. A check makes check_edit measure the rule: length: At most {max} seconds long. loudness: Integrated loudness in LUFS: {target, tolerance} (default -14 ± 1). pauses: No silence longer than {max} seconds (default 0.4), quieter than {floor} dB (default -35). peak: True peak in dBTP: {max} (default -1).

Check each new edit before you show it. It compares the edit with its take: sound, picture, sync, cut words, undone fixes, rules with a check. Fix each failure in a new version and check that. pass null: did not run (skip says why). A failure looks wrong: tell the user its say. review: with a Gemini key, Gemini watches the edit with the rules (about 5 cents, cached per version); without one, a frame sheet for you to look at. Follow review.note.

Make or change an image straight from Google or OpenAI (much cheaper than a Higgsfield image: never use higgsfield for images). Drafts first, final last: while the user finds the direction, draw with GPT Image (fast, 1536 px at most): flare (GPT Image 2.5 Flare, the default for a new image) or sunburst (GPT Image 2.5 Sunburst, the default for a change or with references). When the user likes a draft, make its final: from= redraws it with Nano Banana 2.1 at 4K, the newest and sharpest, with the draft and its references as the guide and the same prompt (add one only for a change). Never make a final before the user picks. When one model fails the next one draws. Waits about 10-60 s and returns the file, /generated/-vN.png, and the model that drew it; the Assets tab shows both. Change an image: images=[session files] (a thumbnail, a still, 'sketch' with shot=) and say what to change. One image per ask.

ElevenLabs voices: the account's own voices (the user's clone, designed and saved voices), the default voice, the plan and characters left. search= searches the ElevenLabs voice library (with gender, accent, language, age, use_case); add= with name saves one to the account; set_default= makes a voice the default. Not set up: tell the user to open Plugins › Voices.

Design a new ElevenLabs voice from a description ('warm German woman, 40s, calm, slow'): writes three samples (generated/voice--1..3.mp3 with session, else _library/voices/) for the user to hear on the Assets tab. Then save the pick: save=<the sample's save id> with name.

Make a voice-over with ElevenLabs: reads text (default: the session's script.md) in a voice (default: The user's default voice, usually a clone) and writes generated/-vN.wav (48 kHz mono, -14 LUFS), shown on the Assets tab with the voice's name. Write the text as spoken words only. Costs ElevenLabs characters (about one per letter): one voice-over per ask.

Correct what was said in a take or clip: ElevenLabs says the new words in the voice (default: The user's default voice, often a clone) with the sentences around them for the same tone, and Takes cuts them in at the word edges with the take's cleaned voice when there is one. old = the words as said (from the transcript; Takes transcribes the file first when it has no .words.json), or start/end in seconds. Writes generated/-fix-vN.wav, plus an .mp4 with the video when the new words fit the old time (speed 0.8-1.25x), so the take's times still hold. The lips do not move with the new words: say so when the fix is on camera.

Say a clip again in another voice with the ElevenLabs voice changer: same words, timing and emotion. The user acts the line, a character voice comes out. Whole file or start/end (at most 5 minutes); writes generated/--vN.wav, and an .mp4 with the video for a video.

Make or change a video with Higgsfield (Seedance, Kling, Veo and 30+ more video models) from inside Takes. Video only: images go to make_image. Returns at once; the job runs in the background and the file lands in /generated/-vN, where the Assets tab shows it. With shot= the storyboard shot shows 'Generating' and then plays the clip (aspect ratio = the storyboard format, length = the shot's length, 4-15 s). For a shot, write a real-footage prompt from the shot's do and say (subject, setting, light, camera move); pass image='sketch' to use the sketch only as a composition reference with params {mode: omni_reference}, and say in the prompt that the result is real footage, not a drawing. Change a video: video= with params {mode: video_edit} (Seedance; the takes-alter skill has the method: target frame, 480p draft, check, finalise), or workflow=reframe with aspect_ratio for a new shape. Default model: the one the user picked on Plugins › Higgsfield (higgsfield_status default_model); other models by id (higgsfield model list in Bash; higgsfield model get <id> for params). Each job costs the user's Higgsfield credits: one job per ask, never a batch nobody asked for. Not installed or not signed in: tell the user to open Plugins › Higgsfield.

Is Higgsfield installed and signed in, and how many credits are left; with session, its Higgsfield jobs (running, done, error).

Make or change a video on Replicate: the same models as Higgsfield (Seedance 2.5, Kling, Veo, ...) at a price per second of video, no plan. Returns at once; the job runs in the background and the file lands in /generated/-vN.mp4, where the Assets tab shows it. model: owner/name; leave it out for the user's default (replicate_status lists the default models, the first is the default; pick another of them when it fits better). Takes maps prompt, image (the FIRST FRAME), end_image, video, duration, aspect_ratio, resolution and audio to the model's own input names; anything else goes in params by the model's names (call replicate_model first to see its inputs, defaults and allowed values). File inputs, in those fields or params, take a session file, a take number or 'sketch' (the shot's sketch); Takes uploads them. With shot= the storyboard shot shows 'Generating' and then plays the clip (aspect ratio = the storyboard format, length = the shot's length, 4-15 s). For a shot, write a real-footage prompt from the shot's do and say; never use the sketch as the first frame (the video would look drawn): pass it only to a reference-image input if the model has one. Each job costs the user money: one job per ask, never a batch nobody asked for. No token: tell the user to open Plugins › Replicate.

A Replicate model's inputs (type, default, allowed values, what each does), so a job can set what the user asks for. Leave model out for the default.

Is a Replicate token set, which account, the user's default video models; with session, its Replicate jobs (running, done, error).

The path for a new file: the right folder and the next version. kind=edit: /edits/-vN.mp4. kind=thumbnail: /thumbnails/-vN.png (the edit's name, plus an option word for several). kind=library: /assets//-vN.. Call it before you write any of these. For edit and thumbnail it also gives the user's rules for that step once per chat: follow them.

Read the style a video uses: The user picks one of the named styles per video or per project (e.g. Magazine), and the project library adds to it. Returns the style's name and 'template', the style library and the project library (README.md style guide, tokens.json colours/type/spacing/radius, assets by group with every version, fonts, open comment counts) and the merged tokens. Without project: the list of styles. Read it before you design anything: a thumbnail, captions, a motion graphic, a slide.

Ready-made effects for talking-head videos (text behind the head, a glass chart, a freeze-frame sticker, a tier list...), each with a preview, a README and a HyperFrames source. Opt-in: call it only when the user names an effect or asks which effects there are, never to pick one yourself. With effect: its README and source.

Set the style of one video (session) or of a whole project. The user usually picks it on the app's Assets tab. Only when asked.

Keep a reusable part of an edit in the style library: a title card, lower third, caption look, transition, cover layout, sound. It becomes the next version of assets//, with your note, and shows on the app's Styles board, where the user comments on it. Do it after each edit for every part a later video could use again. Save a playable preview (.mp4 or .png), and pass source_dir to keep the HyperFrames composition that makes it.

Start a new style from an example the user gives: a link, a video, an image, or words. Makes the style folder (status new) and returns the steps: study the source, write the guide and tokens, build the parts, render the preview. The user compares it with the other styles on the Styles board and keeps or trashes it.

Copy library files from one library to another: 'style:' or a project name (copy to a new 'style:' to start a new style from an old one). items are paths inside the library (README.md, tokens.json, assets/Logos/mark-v2.svg); omit for everything. tokens.json merges by token name; other existing files are skipped, never overwritten. move=true trashes the copied files in the source.

Add alternative versions of the script (e.g. 'Punchy hook', 'Story first'). Each shows up as a tab above the teleprompter; the user can read any of them and pick one as main. Use this instead of overwriting the main script when offering options.

Edit or rename a variant: its script, its name (the tab label) or its note. History keeps the old text.

Mark one script as the favorite (star on its tab): 'main' or a variant id. Omit draft to clear it.

Make a variant the main script. The old main stays in history.

Move variants to the macOS Trash (their text stays in history).

List saved versions of the script and variants, newest first, with author, note and a preview.

Get the full text of one saved version.

Put an old version back (the current text is saved to history first).

Name a take. Its files become take-NN--camera.mov / -screen.mov. Empty name resets.

Add recordings that already exist (e.g. from QuickTime, a phone, a download, or files placed in the session folder) to a session as takes. Never edit session.json by hand: this names the file take-NN-[name-]camera., gives it the next take number, reads its length and lists it. One take: path (+ screen_path for its screen recording). Several: takes=[{path, screen_path, name, keeper}], one take each, in order. Files outside the session are copied (move=true moves them); files already in the session folder are renamed in place.

The videos the user AirDropped from an iPhone that wait in ~/Downloads (AirDrop or iPhone recordings only; all=true for every video), oldest first, with length, recording time and, with listen=true, the first words said (Whisper, about 10 s per video). Also lists the newest sessions with the start of each script, so you can match each video to its session and import_take it with move=true.

Star or unstar a take as the keeper.

Mark a session as published once its video is live on social media, so the user and other agents know it is done (the app shows it on the session). One entry per platform; call again for each platform. published=false unmarks (with platform: only that one). The user then cleans up the session's files in the app; do not trash them yourself.

List the user's own b-roll (_library/broll//): self-filmed clips at the desk, hands typing, reactions, lifestyle, outdoor. Each has title, folder, filmed (YYYY-MM), orientation, duration, description, keywords and path. Use it for B-ROLL shots in a storyboard or an edit before asking the user to film new b-roll. The user browses the same clips on the app's B-roll tab.

Find footage by meaning across the whole library, on this Mac: clips by what they show ('hands typing', 'walking outside at night', 'close-up of a phone'), stills and thumbnails, and the words said in transcripts and scripts ('where I talk about pricing'). Each hit has path, kind (video, image, speech, script) and, for video and speech, 'at' (seconds into the file). A b-roll clip found by its description has 'about' (that description). Best hit first. Use it to find b-roll for a storyboard shot or an edit before asking the user to film it, and to find an old take or clip the user describes. Same search as ⌘K in the app.

Put b-roll clips into a session's broll/ folder (an APFS clone: no extra disk space), so they show on its Assets tab next to the takes. Use the file from list_broll.

List the user's music and sound effects (_library/audio/Music, SFX, ...): file, title, artist, genre, bpm, duration, path. New downloads in the source folder (Epidemic Sound) are copied in first. Use for picking a song or an SFX for an edit. SFX are short effects (whoosh, pop, typing, notification). Mix songs and effects into a new version of the edit with ffmpeg, under the voice: the app plays only the file, never a song or an effect beside it. The app's Use button asks you for this.

Move takes to the macOS Trash (recoverable). Pass take numbers, or non_keepers=true to trash every take without a star.

Move whole sessions to the macOS Trash (recoverable).

Move sessions to another project (created if missing).

Make a take's voice sound like a proper mic (the user's voice-cleanup: room echo, noise, clipping, hum, then EQ, compressor and loudness). The first call starts it in the background (about 15-60 s per minute of audio); get_session then shows 'voice' under the take, with 'file' when it is done: use that WAV as the take's voice in edits instead of the audio in the .mov. Later calls only change the settings (instant). The user sets the same in the app's player.

Set the best cut of a storyboard take after you checked it. The best_cut from Gemini (or from the transcript, without a key) is only a first suggestion: compare it with the transcript and the frames, then write the range you use here (by=agent; the first range stays under gemini). The user sees it on the take in the Storyboard tab. This only marks a range. To make the clip, call cut_take with that range.

Cut takes into one clip: video at a constant frame rate, the voice in sync, and word times for the clip. It is the default for a cut of a take: it fixes the take's audio offset and frame rate, moves a cut point that falls inside a word to the word's edge (listed in 'moved'), and uses the take's clean voice when clean_voice is done. For what it cannot do (a J/L cut, a speed change, a cut inside a word, an effect), use your own ffmpeg on its clip and .wav, or on the take with get_session's audio_offset_s, and tell the user what you did. set_best_cut only marks a range; cut_take makes the video. Writes _work/-vN.mp4, .wav (voice only) and .words.json in the session. A short cut comes back done; a long one returns a job.

Make a first cut of the takes against script.md: each script line once (the last full try), without false starts, stutters, ums and pauses longer than gap. A take with a best cut uses only that range. Returns the clip (like cut_take) plus dropped (each with why) and missing (script lines no take has). Show the user the clip and tell them what you dropped and what is missing. It is only a first draft: improve it freely (edit cut and call cut_take; see cut_take for your own ffmpeg).

Build an edit from a recipe, as a job, and check it. First version: recipe={name, cut} (cut = rough_cut's cut) plus what you need: frame {shape '9:16'|'16:9'|'1:1'|'4:5'|'source', crop}, over (picture layers: alpha graphics or b-roll, with at/in/out), music and sfx (file, at, gain_db), steps (commands that make the layers, run in _edit//), cover (a thumbnail). Next version: base= and changes (a JSON merge patch on the newest recipe; a list replaces the whole list; {"name": "hook-vertical"} starts a new line). Takes uses the clean voice once and never uses a finished edit as an input. One render of a name runs at a time: to compare two options, give the second a new name. Returns a job; then publish_edit.

Save a checked render as the next version, edits/-vN.mp4, with its recipe. In one call: reads the checks the render ran (it refuses on a failed check; accept=[{rule, why}] for a fail you meant), puts the version on the posts that follow this edit (a version the user picked stays), answers the review comments it fixes (replies: like reply_comment; fixed_in and resolve are set for you) and saves note as the changelog line. Call it once per version. To show another file on a post, call set_post media=... after. Its review (Gemini watched it, or a frame sheet when there is no key) is for the next version: follow review.note.

The recipe of an edit: how it was made (cut list, voice, layers, music, sfx, cover, checks, the exact commands) and the versions before it. get_session shows a short form of the newest one.

Export an edit version as a timeline for DaVinci Resolve, Premiere Pro or Final Cut Pro, made from its recipe: edits/-vN.fcpxml (Resolve, Final Cut), .premiere.xml (Premiere) and .edl (picture cut only), next to the version. They link the original take files with the cut's in and out points and the voice as a WAV on the video clock (the clean voice when the recipe used it). left_out lists what the timeline does not carry (cover, crop, loudness, music ducking). Only when the user asks for it.

Save a video of a session into the user's b-roll library (_library/broll//, an APFS clone), so every session can use it (list_broll, add_broll). Gemini describes it in the background and writes the description and keywords into the clip. Only on the user's ask.

Offer the user a project, session or file (e.g. a new edit) in the Takes app. It never takes focus or plays anything: the session gets a dot and opens only on a click. Once per finished result, not for drafts or in-between steps.

Run slow work (a render, Demucs, Whisper, matting, any command over about 30 s) in Takes, never as a background Bash job or with sleep. Returns a job id at once. The job outlives the chat and Takes, and shows its progress in the session's Jobs row. cmd runs in zsh in the session folder. The result's note says how to wait.

A job's status (starting, running, done, failed, stopped, lost), progress, time left, last log lines, exit code and files. wait_s waits for the end in this call (other takes tools wait too); call again to keep waiting. With session and no id: the running jobs and those that ended in the last day.

Stop a running job and every process it started. Files it wrote so far leave the session (they go to its .jobs folder). Higgsfield and Replicate clips cannot be stopped.