Docs › Studio: Crew for media

Studio: Crew for media

Beta. Studio works and is part of the licence, but it is newer than the core and may change between versions. It needs a machine with an NVIDIA graphics card and about 30 GB of disk for local pictures and clips, and API keys for the services you pick (see Requirements).

Describe a video on any subject ("a 90-second promo for my app, in English and Turkish", "two minutes on how sourdough rises"), point Studio at a project folder, or give it your own footage to cut into a montage, tighten, summarize, narrate, dub, or give another voice or face (see Your own footage). A Director plans it as a storyboard and picks the right tool for each step: a voice model, a transcriber, a renderer. Studio runs the steps, the heavy ones on your spare machines. It checks every result, redoes what's wrong and hands you finished files: the videos, thumbnails, captions and the YouTube text.

It's in the dashboard, on the Studio tab. The Director is Crew's Master (see Crew), so Studio needs Crew with a Claude agent, or a Gemini API key. Members of your dashboard can make their own videos too, on their credits (see For members). A storyboard to approve, or a finished video that needs your eyes, shows in a banner at the top. The list of productions filters to what needs you, what is active or what is finished, and has a search. The languages, length, priority, captions and Local only choices sit under Options, which shows what they're set to while it's closed. What you type is kept as a draft until you start it (⌘/Ctrl+Enter starts it).

How a production runs

1. You describe it. Pick a recipe (Product promo, How-to tutorial, Explainer… see Recipes), write what you want, and choose the languages (en,tr), the length, the priority (quality, balanced or cheapest) and the format: landscape 16:9 for YouTube or vertical 9:16 for Shorts, Reels and TikTok (see Vertical videos). Local only keeps every step on your own machines. 🕶 Private erases the production once you have downloaded it (see Private productions). 🔞 Adult allows the nudity of fictional adults, on your own machines only (see Adult productions). Make it all with Gemini (see Make it all with Gemini) has this production's pictures, clips and voice made with Gemini's tools, and shows what that costs before you start. You can attach screenshots or a logo, as in Crew. Choose the subject and, if you like, a project folder (see Brand kits) and the look (see Looks). The length is the voice-over's: the Director is told how many words and characters fit, from how fast the brand kit's voice spoke in its earlier videos in that language (else any video's in it, else 2.4 words a second), and a storyboard a third too long goes back to it. A slow storyteller for small children says about half as much a second as a promo's narrator. Under the form, a line says about what the production would cost as the form stands, and changes as you change it: About $1.95: pictures $0.67, clips $0.80, voices $0.09, machine time $0.00, Director $0.39. It is a dry run, before there is a storyboard: about a made picture for every 18 seconds, the clips within Settings' limit (one for every 45 seconds; 3, or 4 over two minutes, for a brand kit that shoots close), the voice at the language's pace in every language, the Director's calls, and the render's machine minutes, each with the tool Studio would choose now. Pictures and clips made on a paid machine (Made on) are paid by the hour, so they count under machine time, with your own machines' minutes at prices.jobs.costPerMinute (nothing when it isn't set). Hover it for the counts. Footage recipes make no pictures or clips. The storyboard's estimate is the real figure; nothing is paid for before you see it. ({"action": "quote", …} with the form's fields on POST /api/studio gives the same figures.)
2. The Director plans a storyboard. It reads the project folder, or your product's documentation (or the brand kit's), and writes the scenes: for each, the lines the narrator says and what's on screen, and who speaks them (one voice, or a voice for each speaker: its call). It is told what each of its choices costs with your tools (the voice per 1,000 characters, a made picture, a clip made with AI, music, sound effects) and spends only where it shows: a free stock photo or a drawn scene where it's as good, a made picture or clip only where nothing free shows it as well. Between two tools of the same quality, Studio always takes the cheaper one, whatever the priority. It lists every claim with the file that supports it. Studio checks the storyboard before you see it: things the brand kit says never to claim, words the brand never uses, icons the scenes can't draw, and cues that point at a word the line doesn't have. Anything wrong goes back to the Director.
3. You approve it. The storyboard is there to read as soon as the Director is done. You see the tool chosen for every step and why, the cost, and under Where, and how long one line per part (pictures, clips, voice, timing, scenes): where it is made, about how long it takes and what it costs, and the time from here on. The pictures and the clips go to every maker that can make them at once (each machine set up for them, and the cloud models with a key), each named with its seconds a picture, and the line offers three choices: Fastest (every maker), Free, on my machines (only those), Cheapest; hover one to see what it would take ("all 21 on Gemini images: about 5 min, about $0.80"; "ComfyUI pictures on myworker and this computer: about 40 min, free"). Without a choice the production's priority decides. The tool dropdown above still pins a part to one tool, and each picture on the storyboard has a Make with… menu for that one scene. A machine that costs money by the hour (a cloud worker, or a rented one with a price from sparehand set NAME price) is listed under Paid machines with what the parts would take there and cost ("runpod (24 GB GPU, $0.27 an hour): about 6 min of pictures and 45 min of clips, about $0.25"), but is never used until you tick it for this production; only the owner can, and a member's production gets one only when the owner ticks it. Its pictures (photos, made pictures, cheap clips, the music and sounds) are made in the background while it is open: the production says how far they are and how long the queues have left (Storyboard ready: making the pictures, 5 of 21, about 12 min left), and each shows up as it is made, saying who made it and how long it took. You can change a tool, edit any line, remove a scene, or ask for a new storyboard with notes; you don't have to wait for the pictures to approve it, and Stop the pictures stops only them (the rest are made when you approve).
4. The steps run, side by side where they can. While they do, the production's page lists its stages (Storyboard, Pictures, Translation, Voice, Timing, Layout check, Scenes, Video), each ticked when it's done, with how many of its steps are done and about how long is left; the production's row says it too (Working · about 12 min left). A stage takes the storyboard's estimate until its first steps are done, then goes by how fast they went. For each language:
   • Translation by the Director: natural spoken lines, every text on screen. Brand names, commands and code stay as they are.
   • Voice: one file per line, in the voice the Director chose for the video (or Studio's voice for that language).
   • Timing: Whisper, on a spare machine, listens to every line and times each word. A line where a word wasn't heard is made again. If it's still wrong after the review rounds, it's marked needs your eyes.
   • Layout check: a key frame of every scene is drawn and checked for text that runs off the screen, overlaps, wraps badly, uses a glyph the font doesn't have, or wasn't translated. The Director looks at the frames, keeping to what you asked for, and fixes the scenes. A picture that goes against it (a real photo when you asked for cartoons) is made again with AI. The fixes are checked again. The pictures are the same in every language, so only the first language's check judges them (a new picture then shows in every language); the other languages' checks look only at their own words on screen.
   • Continuity: with the layout check, the Director (one that can look at pictures) also lays every picture of the video side by side, in story order, with the brand kit's reference pictures (its *-reference.* assets), its people and its picture rules, in one look a round. It catches a person who looks different from their reference or from earlier scenes (a toddler drawn as a boy in one scene, a grandmother suddenly young or in someone else's braids), someone who vanishes or is replaced without the lines saying so (in her bed in one scene, the bed empty in the next wide shot of the room), and a wide shot that shows fewer people than the room holds. When every picture is made free on your own machines (ComfyUI), such a picture is made again from the Director's new description, like any wrong picture (up to five times a scene, each time as candidates the Director picks from: see Candidates). A picture made with a paid tool (Gemini images, a paid machine) is never made again by a check by itself, nor its clip: that would be money the storyboard didn't say (one production's three clips were each bought three times, $7.20 where $2.40 was planned). The scene is marked needs your eyes with what the check found and what a remake would cost (the picture, and its clip in a clip scene), and a Remake for $X button: it is made then (that price is added to what the production may spend), or keep it (Looks fine: the checks leave that picture be), or put in your own. The same goes for the layout check's new pictures and a main picture's check (below). One a new picture can't fix, or one past the limit, is marked needs your eyes with the reason, not counted as fixed. Unchanged pictures aren't compared again. A remade picture replaces the one it had only when it's better: the Director looks at both side by side against the scene's checklist (the right people, their looks from the kit's reference pictures, how many, their pose). When it isn't better, the one it had stays, the remade one becomes a candidate (Next candidate shows it), and the scene is marked needs your eyes with the reason instead of being made again. Before a remake is made, its new description is checked against the kit's picture rules: one that drops the marks of someone's look (glasses, a beard, curls, braids, a headscarf), or gives them to someone who doesn't have them, goes back to the Director, and what is still missing then is put back in the kit's own words.
   • Scenes: each scene is rendered on its own, on whichever machine is free, so three machines are about three times as fast as one. Every machine codes its scenes the same way (H.264 High 4.0, yuv420p, limited range, BT.709), whatever ffmpeg it has: the scenes are joined without re-encoding, and a join of scenes coded differently (full range from one ffmpeg, limited from another) made ffmpeg hang on the hub. A scene made before this, or by a machine that can't, is coded again the same way before the join, and the production's events say which and why; a video joined from such scenes is coded once more before the brand kit's intro and ending go around it.
   • Encode: the scenes are joined and the voice added at YouTube's loudness (-14 LUFS).
5. Your files. Per language: the MP4 (1920×1080, or 1080×1920 vertical; 30 fps), the thumbnail (1280×720, or a 1080×1920 cover), the captions as an .srt, the voice as a WAV, and the YouTube title, description and chapters, taken from the real timings. You can also have the captions drawn into the video (see Captions in the picture) and upload it to YouTube from Studio (see Upload to YouTube). More from this video makes vertical cuts, other languages, a square cut, thumbnails and subtitles from it (see More from this video).
6. Tell the Director. On a finished video, write what to change in your own words ("no real people, every picture a cartoon", "the picture in scene rahman is wrong"). The Director changes only the scenes your notes touch, and only those are made again. It keeps to your notes for the rest of that video. If the change needs a new storyboard (scenes added or removed), it says so and offers to plan it again. For one precise change (a shot, a line, a cut, two scenes swapped), use Change… instead: it shows what will be made again and what it costs before anything is made, and keeps the version before (see Change…).

A rough cut first

A storyboard reads well, but a video is judged by watching it. With a rough cut, Studio shows you the video in a minute or two, before any clip is made: each scene is its picture with a simple camera move (a push in, a pull out, a pan, or a hold), at the length its lines take, so the cuts fall where the finished video's will; the lines in the real voice where they are made already, else in this computer's quick voice (macOS's, when its tool isn't switched off; without one the line is silent for as long as it would take); the music bed under them, quieter while someone speaks; and the captions, shown by the page's player. A scene whose picture isn't made yet shows a card in the kit's colour, with its title at the top. It is made at 1280×720 (720×1280 vertical) with ffmpeg on this computer: no video model, no graphics card, nothing paid.

Rough cut in the form's Options (and in a brand kit, and in Studio → Settings for everything else) chooses when:

• Straight through (no rough cut): as before, the video is made when you approve the storyboard. This is the default.
• After I approve the storyboard: approving it makes the pictures and the rough cut, and the production waits (Rough cut ready: approve it). Under the video: Approve and make the clips makes the clips and the finished video; Change… takes it back to the storyboard, where you edit what you like and approve it again for a new rough cut (the pictures made are kept, and so are the rough cut's scenes that didn't change, so it is quicker the second time). The time and cost of the rest are shown beside the buttons, with Where, and how long.
• Right away, with the storyboard's pictures: the rough cut is made as soon as the storyboard's pictures are, while you read it, and made again after a change; approving the storyboard approves it.

Until the rough cut is approved, nothing is made on a paid machine and no clip is made, whatever it would cost: a paid machine you ticked (or chose under Made on) isn't started, and the pictures go to your free machines (a production made on a paid machine shows cards until then). The storyboard also has Make a rough cut now in any of the three, to see one before you decide. The production's log says how long each part took (Rough cut ready (1:04): made in 38 s on this computer after the pictures (95 s). Timing: voices 6 s (12 quick), scenes 25 s (7 of 7 new), join 7 s.). Your own footage and solo pictures have no rough cut: there is nothing to draw before the cut.

{"action": "draft-mode", "id": …, "mode": "off" | "first" | "now"}, "approve-draft", "change-draft" and "make-draft" on POST /api/studio do the same; "draft" on start, in a brand kit and in the settings.

Clips without the wait

Before, every clip made on your machines started a fresh ComfyUI and stopped it after: on a rented A40 about 90 seconds of every action shot went to starting ComfyUI and loading the clip model again, before the clip itself. Now a production's clips on one machine share one ComfyUI, kept warm between them (kit/comfy.py clip --warm <production> --last 0|1): the next clip with the same model starts at once. The clip after it is let onto the machine although the warm ComfyUI holds its memory (that memory is the model it needs: Sparehand's 30% free rule is lowered to 10% for that one job); if the warm one is gone by then and the machine is short of memory, the clip ends and is tried again with the usual room. Clips that don't depend on each other go to every machine that can make them at once (your machines, and a paid one you ticked), a film's chained shots one after another on the machine of the first. Each clip's line in the production's log says where its time went: ComfyUI clips: made on myworker in 352 s. Timing: ComfyUI 0 s (warm), upload 0 s, make 340 s, fetch 1 s; Sparehand (machine, sync, results) 11 s.

Choose the Brand on the form:

• No brand: a recipe, a lesson, your open-source library, a talk. There's no logo end card, no product name unless the subject has one, and no brand rules. The Director picks the tone that suits the subject, and lists the source of every fact (your description, a file, or general knowledge).
• A brand kit: the video is about that product, with its name, logo, tone, colours and rules (see Brand kits). Choosing a product's project folder picks its kit by itself.

Project folder: choose a folder on this computer (Browse…, or type its path) and the Director makes the video from what's in it. It works in that folder and reads what it needs: the README and docs first, then whatever your description points at. Every claim must come from one of its files. Its pictures (up to 24, leaving out dependencies such as node_modules) become images the scenes and the thumbnail can show, named after their path (docs/img/loaf.png is docs-img-loaf.png). Choosing a folder sets the subject to Anything; set it back to the brand kit for a video about your product made from that folder. A Director that can't open files itself (Gemini through the API) is given the folder's file list and the text of its first files instead.

The folder is only read, never changed. (A brand kit can save the finished videos to a folder of your own: see Save finished videos to.)

Real pictures: photos and video

Besides the drawn scenes (titles, cards, diagrams), the Director can fill a scene with a real picture: a photo or a video across the whole screen, slowly moving, with a short heading, a caption and labels that point at places in it. For a video about the real world (a science explainer, a place, a recipe), most scenes are pictures, and the drawn ones are kept for lists, steps and numbers.

Each picture comes from one of three tools:

• Stock photos and video (Pixabay or Pexels): the Director writes a search for the scene ("blue sky clouds", "eye looking around") and Studio takes the best match: a photo, or a video clip that loops for the length of the scene. Both libraries are free with a key:
  • Pixabay: sign up at pixabay.com, and your key is on its API documentation page. Enter it under Studio → Settings → Pixabay API key (or sparehand studio key pixabay).
  • Pexels: a key from pexels.com/api, under Pexels API key (or sparehand studio key pexels). Pexels sometimes pauses giving out new keys.

With both keys, Studio uses one and you can redo a picture with the other (Redo with another tool). The creators are credited in the YouTube text.

• Pictures made with AI (Gemini images): for what a camera can't take (the inside of the eye, a cell, the past), the Director describes the picture and Gemini's image model makes it, in the video's shape, with no text in it. It uses the Gemini API key you already have, and costs a few cents a picture (Studio's estimate says how much: $0.067 with the default Gemini 3.1 Flash Image, $0.034 with Nano Banana 2.1, $0.134 with Gemini 3 Pro Image, chosen as the model on its card; a setting that still names a -preview model is priced the same). The YouTube text says some pictures were made with AI. A made picture can get details wrong: check it.

It takes reference pictures too. With a brand kit, each picture gets the kit's solo picture of every person its prompt names (by the kit's name for them: at most four, Gemini's limit for people) and the picture of its place (the kit's, else the empty room this video's layered scenes stand in), each sent after a line saying whose it is ("Reference picture 2: Leo, 2, the toddler brother: how Leo looks"), made at most 1024 pixels a side so a request stays a few hundred KB. The kit's group pictures give way to the solo ones (a picture with others in it lends its looks to the wrong person) unless someone in the picture has no solo picture; a picture you attached is sent as it is. Gemini follows a long description well, so the Director writes each generate as a paragraph of 60 to 150 words: the style, the place and its light, how many people, then each one from left to right by their kit name with their pose, where they look and what their hands do. A kit that sets Gemini images as its picture tool has its whole pictures made there; its layered scenes still go to ComfyUI, the tool that cuts people out (below). On two family scenes with four people (a sofa, a dining table), where FLUX.2 [klein] 4B lost the father's glasses and beard and stood a toddler up, Gemini 3.1 Flash Image got everyone right the first time, in about 15 seconds.

• Video clips made with AI (Gemini video, Gemini Omni): for the few scenes where real motion matters (the setting that opens the video, the one moment the story turns on), the Director can ask for a clip instead of a still: in a video scene, animate describes what is seen and what moves; in a photo scene with generate, animate sets the made picture moving (the picture is made first and becomes the clip's first frame). It uses the Gemini API key too. See below.

Make it all with Gemini

Make it all with Gemini under Options on the new-production form makes this one production's pictures with Gemini images, its clips with Gemini video (Omni) and its voice with the brand kit's Gemini voice tool (Gemini TTS when the kit has none), whatever the priority and the tools the kit or Studio would pick. Nothing else changes: the brand kit and Studio's settings stay as they are, and the production's tools can still be changed on its storyboard. It needs the Gemini API key and those tools switched on, and can't go with Local only.

While it is ticked, the form shows what it would cost at Studio's prices for the length, languages and kit chosen: about one made picture every 18 seconds, the clips (3, or 4 over two minutes, for a kit shot close; else one every 45 seconds; never more than Settings allows) and the voice at the kit's pace, for example about $3.88 for a 3-minute video: 10 pictures $0.67, 4 clips $3.20, voice $0.01. The Director's own cost comes on top, as usual (nothing on a Claude subscription). From the terminal: {"action":"gemini-quote","seconds":180,"langs":"tr","brand":"<kit>"} and "allGemini": true on start.

Clips made with AI

A clip is a few seconds long (Gemini Omni makes 8 seconds, at 1280×720; a model that takes a length, such as Wan 2.2 or a Veo model on an endpoint of your own, is asked for the shortest that fills the scene). A clip plays once, at its own speed: when it is shorter than its scene, its last frame holds for the rest, slowly zooming in, so the scene never shows the same moment twice or in slow motion (stock video still loops). The Director keeps a clip's scene about as long as the clip, and gives longer narration a second scene, a picture of the same place. A clip gets the scene's heading, caption and labels like any video.

Clips cost far more than pictures, so Studio keeps them in check:

• A few per production. The Director uses animate in at most 3 scenes (Studio → Settings → Clips made with AI, 0 switches them off). A storyboard with more goes back to it.
• The cost on the storyboard. The estimate says how many clips there are, how many seconds, and about what they cost with the chosen model (the price per second is in the registry).
• Asked first. Clips that together cost more than $2 (Ask first over $) aren't made with the storyboard: they are made when you approve it, or press Make the clips now to see them before you approve. Cheaper clips are made while the storyboard is open, like pictures.
• Never bought again by a check. A check that finds a clip scene's picture wrong doesn't make the picture and its clip again by itself: it asks, with the price (Remake for $X, see Continuity).
• Except on a paid machine of yours, within an allowance. A picture made with ComfyUI on a rented machine costs its minutes there, usually well under a cent, and a check that asked first for each one left whole videos with the pictures it had sent back. So the checks make pictures and clips again there by themselves, up to 50 cents a production (Studio → Settings → Remakes by the checks on a paid machine, 0 to 20 dollars; 0 asks first every time). The storyboard's limit includes it and says so. A tool with its own price (Gemini images, a clip service) is still never bought again by a check, and neither is anything in a member's production.

What a production may spend

When you approve a storyboard, Studio notes what it is planned to cost: what was spent so far (the storyboard's pictures, clips and sounds), the estimate from here on, the time its pictures and clips still to make take on a paid machine it was given (at that machine's measured seconds a picture or clip, and its price an hour), and any Remake for $X you pressed on the storyboard. From then on, paid work that would take the production past that plus 25% (at least 10 cents more; Studio → Settings → Ask before going over the estimate by, 0 to 500%) isn't done: the production stops before it, says what it was about to make and what it would cost, and asks. A picture or clip on a paid machine is checked against it before the job starts; a voice line or anything under half a cent never stops it. A paid machine's idle time (a pod waiting for its idle stop) isn't counted against a production: only the minutes of its own jobs are. Allow $X more and carry on raises the limit (by what it needs plus the margin again) and resumes; or change the tools first (a free one on your own machines) and press Resume. A notification says it stopped. What counts is what the tools bill: pictures, clips, sounds, voices, a Director billed per use and paid machines' hours; a Director on your Claude subscription or on your own machines counts nothing. A Remake for $X you press is added to the limit. A new storyboard (plan it again) gets its own limit when you approve it. Members' productions have theirs in credits instead (a run's cap, below).

The production's page shows the spend next to the estimate, split by tool: $2.94 spent of about $3.00 planned (Studio asks before passing $3.75), then Gemini video $2.40 (3) · Gemini images $0.54 (8)….

Each clip is a job at Google that runs in the background: Studio asks for it, looks every few seconds until it is done (about 40 seconds for an 8-second Omni clip), and downloads it. Redo makes it again, Redo with these notes says what to change. A clip that can't be made (a safety filter, a limit) is marked needs your eyes, and its scene shows its made picture, or its text on a plain background. The YouTube text says some clips were made with AI.

The model is chosen on the Gemini video card: Gemini Omni Flash (gemini-omni-1.1-flash, the default, about $0.10 a second at 720p, so about $0.80 a clip) or its preview. Both go through the Interactions API: a description makes a clip from nothing, a made picture is set moving (its first frame). Google shut the Veo 3.1 previews down on 22 October 2026, so they are no longer offered; a model named veo-… still goes through Veo's own API, for an endpoint of your own that has one. Google retires preview models every few months: when one stops working, pick another, or set the model, endpoint and cost of the gemini-video tool in ~/.config/sparehand/studio.json.

Higgsfield video (optional)

Higgsfield video makes clips with Higgsfield's API (ByteDance's Seedance), for the scenes a local clip gets wrong. It is off until you switch it on under Studio → Settings → Tools, and needs its own key:

• The API balance is not a plan's credits. Higgsfield's API is paid from a prepaid US-dollar balance at open.higgsfield.ai (at least $5, it lasts a year), separate from a higgsfield.ai plan and its credits, which the API can't use. Top it up there, make a key, and paste its key ID and secret as KEY_ID:KEY_SECRET under Studio → Settings → Higgsfield API key. It is kept in the Keychain (service sparehand-studio, account higgsfield), or comes from SPAREHAND_STUDIO_KEY_HIGGSFIELD.
• The model is chosen on its card. Seedance 2.0 from the scene's picture (bytedance/seedance-2.0/image-to-video, the default and the cheapest, about $0.14 a second at 480p, so about $0.55 for a 4-second clip) or Seedance 2.5 (about $0.21 a second at 480p; at 720p about $0.30 and $0.46), each also as reference-to-video. With image-to-video the scene's start picture is the clip's first frame. With reference-to-video the start picture and the kit's pictures of the people in the scene go as reference pictures instead, so faces are kept better but the first frame can differ: Higgsfield takes one or the other, never both. Seedance 2.0 Mini, on the website, isn't on the API.
• Its price is asked first. The registry's price per second (480p, without sound: Studio adds its own) goes into the estimate, Ask first over $ and the production's spend limit, like any clip. Before each clip Studio also asks Higgsfield what it costs (for Seedance, Higgsfield answers with a price a second or per 1,000 video tokens, and Studio works out the clip's). Over 1.25 times what Studio counted, it isn't made and the step says why. What Higgsfield said is what is counted as spent. Failed clips, and clips held back by its moderation, aren't charged.
• The same checks. Its start picture is checked like any clip's, and Redo with Higgsfield video on one scene (or Make with…) makes just that clip with it.

Each picture is uploaded to Higgsfield first (a link that lasts an hour, sent without the key). Then Studio asks for the clip, looks every 10 seconds until it is done and downloads it. Higgsfield keeps its files for 7 days. The resolution, the lengths (seconds), sound (audio) and the prices (cost.byModel) can be changed for higgsfield-video in studio.json.

Studio makes the pictures in the background while the storyboard waits for your approval, so you read it as soon as the Director is done and see each picture as it arrives, with where it came from; the production's row and its page say how many are there (making the pictures, 5 of 21). A storyboard whose pictures aren't all there yet can be approved all the same: the production waits for them, then makes any that are missing, before anything needs them. Stop the pictures stops only them (the storyboard stays to approve, and the rest are made when you do); a new storyboard with notes cancels the old one's. Don't like one? Redo it for the next match, or Redo with these notes: for a stock picture the notes are a new search ("starry night sky"), for a made one they say what to change. Editing a scene's search, generate or animate on the storyboard fetches its picture again. The thumbnail can use a scene's picture too.

Made on, and when the pictures are made

Two choices under Options on the new-production form, each set to the brand kit's default (Studio → Settings → Brand kits) until you change it for that video:

• Pictures and clips made on: Automatic (Studio spreads them over your free machines, as above) or one machine that can make them, its graphics card deciding which models run. A paid machine is marked with its price an hour ("runpod: $0.59 an hour, started when needed"). The production is given that machine from the start, before the Director has planned anything, so the first picture already goes there and none is made elsewhere meanwhile; a paid one chosen here is ticked under Paid machines too. A paid cloud worker that is stopped is started for it (sparehand cloud start, about 1–2 minutes, stopped again after its idle time) and the production says so: at the start when the pictures are made right away, else when you press Make the pictures or approve the storyboard. A rented machine without a provider can only be started at your provider; the production says that too, and waits for it. A kit's machine that can't make them now (removed, or without the models) makes that video Automatic, and the production says so; chosen on the form, it is refused. A member can't choose a paid machine. The storyboard's own Made on changes it later; changed while the pictures are being made, every picture and clip not started yet goes to the new machine (one already being made finishes where it is), and so do the remakes the checks ask for.
• Pictures made: Right away, while I read the storyboard (as above, the usual), When I press Make the pictures (the storyboard shows that button, and nothing is made before it), or After I approve the storyboard (they are made with the rest, once it is approved). The storyboard says which applies. Until its pictures are made, changing the scenes (a redo, an edit, a new storyboard with notes) costs nothing; a new storyboard waits for the button again. A kit's solo pictures are always made right away (they are what that production makes).

From the API: start takes madeOn (a machine's name, "" for Automatic) and picturesWhen (now, button or approve); left out, the kit's are used. A kit keeps them as madeOn and picturesWhen (Settings → brand), and the action make-pictures is the button.

With neither tool set up, the Director doesn't plan photo or video scenes. If a picture can't be found, its scene shows its text on a plain background and is marked needs your eyes.

Pictures and clips on your own machines

Pictures and clips can also be made on a machine of yours with an NVIDIA graphics card, with nothing sent anywhere and nothing to pay: ComfyUI pictures and ComfyUI clips in Studio → Settings → Tools. Both come switched off. They run ComfyUI with open models:

• Pictures: FLUX.2 [klein] 4B (Apache 2.0), in four steps. It keeps a character the same from scene to scene: attach a picture of them (say elif.png) and the Director gives each picture of them ref: "elif.png". Without one, it describes the character fully in their first scene, and the later pictures take that scene's picture as their reference (ref: "meet", made first). When the brand kit has its own reference pictures (its people's -reference pictures, its places' pictures), a picture is made from those only, never from an earlier scene's: a mistake in one made picture (a girl's face in the window glass, an extra child) would otherwise be copied into every later one. The Director is told so, a scene ref goes back to it, and Studio drops one anyway.

The model is distilled (four steps at cfg 1.0), so a negative prompt does nothing and a long prompt gets muddled: in a 250-word prompt one girl's braids ended up on her grandmother, people went missing or were doubled, and "no braids" or "never bunk beds" tends to draw exactly that. So when the pictures are made by ComfyUI (or any picture command), the Director writes each generate in 40 to 80 words: the style, the place, then each person once from left to right with one pose, in positive words only ("clear window glass", not "no faces in the glass"), at most two people with a pose of their own (a busier moment becomes two scenes), and nothing about text. The same goes for the pictures the layout and continuity checks ask for, and for B-roll; a brand kit's picture rules say what the pictures must show rather than words to copy, and this rule comes before any lesson that asks a prompt for "no" or "never". On its way to the model the prompt also loses any sentence or clause that only says what isn't there, the place's look in words when the place has its own picture (its first sentence otherwise), and the "no text, letters…" line other picture models get: naming text, even to forbid it, can draw some.

• Plain pictures: Z-Image Turbo (Apache 2.0), chosen as the model on the pictures card: sharper and better at a long description, but it takes no reference pictures.
• Clips: Wan 2.2 TI2V 5B (Apache 2.0): the scene's made picture starts moving, up to 5 seconds at 720p (1280×704; 704×1280 for a vertical video), 24 frames a second. The Director is told to keep the movement small (clouds, hair in the wind, a slow turn of the head), which this model does well; big movement and faces close up can drift.
• Clips, 14B: Wan 2.2 I2V 14B (Apache 2.0), chosen as the model on the clips card: quantized (GGUF Q4_K_S) to fit an 8 GB card, with lightx2v's four-step LoRAs (Apache 2.0), so a clip takes 4 steps instead of 20. It keeps the picture's character closer (in the test, the 5B closed a girl's eyes and she fell asleep; the 14B kept her looking up, blinking and smiling as asked) and is about four times faster, but makes 832×480 (480×832 vertical) at 16 frames a second: on 8 GB, 720p takes 20 minutes a step. It always starts from the scene's picture. With clips14b comes RIFE frame interpolation (ComfyUI-Frame-Interpolation and Practical-RIFE 4.9, both MIT): a frame is made between every two, so the clip plays at 32 frames a second and its movement is smooth. sparehand studio status shows smooth as yes where it is set up; without it the clip is made as before.
• Pictures, 9B (a 16 GB card, or an 8 GB one with 24 GB of memory): FLUX.2 [klein] 9B in fp8, with its own Qwen3-8B text encoder (about 18 GB in all), set up with --with pictures9b. The same workflow as the 4B with finer detail and better text in the picture, about twice as slow. On an 8 GB card ComfyUI keeps what doesn't fit in memory, so the machine needs 24 GB of it. It is under Black Forest Labs' FLUX non-commercial licence: not for work that earns money (a monetized channel counts), and a member's production never gets it unless you allow it when you approve their request (below). A machine that has it uses it in place of the 4B by itself, so set it up only where that is what you want. Its download is gated: sign in to Hugging Face, accept the licence on its page, and save a read token in ~/.cache/huggingface/token on that machine (or run hf auth login there) before installing; without it the install says so.
• Clips, 14B in Q8 (a 16 GB card, or an 8 GB one with 30 GB of memory): the same Wan 2.2 I2V 14B, its two experts quantized less (GGUF Q8_0, about 31 GB, Apache 2.0), set up with --with clips14b-q8; a machine that has it uses it in place of the Q4 or the Q6 when the 14B is the clips model. Quantizing less keeps more of the model's detail, and it is made in four steps where the Q6 needs eight, so on an 8 GB card with the memory for it, it is also the faster one (measured below).
• Lip sync, for a film's talking shots (a 40 GB card or more): InfiniteTalk on Wan 2.1 I2V 480p (about 17 GB, Apache 2.0), set up with --with lipsync (see Films).
• Clips, 14B in Q6_K (an 8 GB card with 24 GB of memory or more): the 14B's experts in GGUF Q6_K (about 12 GB each, Apache 2.0), set up with --with clips14b-q6, made in eight steps instead of four: a machine with an 8 GB card that has it uses it in place of the Q4 (a 16 GB card, or an 8 GB one with 30 GB of memory and the Q8's set, takes the Q8). The card holds what it can and the rest stays in memory, so it needs 24 GB of it. Measured below.
• Pictures, Qwen-Image-Edit-2511 (a 24 GB card or more): Alibaba's 20B editing model (Apache 2.0), in fp8 with lightx2v's four-step Lightning merged in (Apache 2.0), set up with --with pictures-qwen (about 30 GB with its Qwen2.5-VL-7B text encoder). A model to choose, not used by itself on any card. Against the 4B on test 5's seven scenes (same prompts and the kit's people's pictures, 2026-10-25, on a 46 GB A40): closer framing, the right number of people every time (the 4B drew one person twice in 14), cleaner lines; but warmer, more saturated colours than the kit's soft pastels, and props less exact (an apple slice came out a whole apple, a tart, a watermelon slice). About 24 seconds a picture warm, against the 4B's 15 with four reference pictures; it takes three (the place's goes first when a scene has more).
• Clips in 1080p (Settings → Clips in 1080p, off unless you choose): Wan's frames made larger on the machine that made the clip, before RIFE adds the frames between, so the video isn't scaled up from 832×480 or 1280×704 at render. It is a second step in the same job, in a fresh ComfyUI: done in one go, the 14B's experts stayed in memory beside the large frames and ran an 8 GB laptop with 25 GB of memory out; when the second step fails, the clip comes as Wan made it, with a note. Real-ESRGAN (its anime video model, BSD-3-Clause, 2.5 MB, --with upscale): about a minute more a clip on a 46 GB A40, any NVIDIA card; clean, flat cartoon lines. SeedVR2 3B (ByteDance, Apache 2.0, about 7.3 GB, --with upscale-hd, a card with 40 GB or more): about five minutes more a clip; as sharp, with more texture and harder outlines, and it can add small things that weren't there (seeds in an apple). Both sharpen a 480p clip clearly and a 720p one a little; neither flickers (a still background changed by under 0.2 of 255 a frame). A machine without the chosen upscaler, or SeedVR2 on a smaller card, makes the clip as before and says so.

Set a machine up once (about 30 GB: ComfyUI with its own PyTorch, and the models), for its user only, with no administrator password. Switch a tool on, and while no machine has its models its card says Not installed, with an Install button: that sets them up on each spare machine with an NVIDIA GPU that is up (for pictures, on this computer when there is none), up to an hour for the download. Or from the terminal:

sparehand studio install myworker --with pictures,clips

--with pictures alone downloads only the picture model (about 12 GB); add plain for Z-Image Turbo (13 GB more), and clips14b for the 14B clip model (about 26 GB, with the ComfyUI-GGUF nodes). For a machine with a graphics card of 16 GB or more, pictures9b (the 9B, about 18 GB) and clips14b-q8 (the 14B in Q8, about 31 GB); for an 8 GB card with 24 GB of memory, clips14b-q6 (the 14B in Q6_K, about 24 GB) and pictures9b too, and with 30 GB, clips14b-q8 as well; with 24 GB or more, pictures-qwen (about 30 GB); for clips in 1080p, upscale (any NVIDIA card) and, with 40 GB or more, upscale-hd; on a smaller card the install refuses them with a note saying which model fits it (pictures9b needs a graphics card with 16 GB or more, or one with 8 GB and 24 GB of memory, and this one has 8 GB and 16 GB of memory: pictures (the 4B) fits it), and sets up the rest. Nothing is downloaded when the disk lacks room for a set and 10 GB to spare: the note says how many GB more are needed, and nothing is grown or deleted for you (a rented pod's volume is yours to grow at the provider). Add a machine offers the two bigger sets as boxes to tick when it makes a cloud machine with a 16 GB card (see Cloud GPU), and sparehand studio install names them when it sets up pictures or clips on such a card without them. sparehand studio status shows pictures, pictures9b, pictures-qwen, plain, clips, clips14b, clips14b-q6, clips14b-q8, upscale and upscale-hd as yes where they are ready, and vram, the card's memory in MB. Every one of these models but the 9B is under Apache-2.0, which allows commercial use; newer ones with research-only or conditional licences (Qwen-Image 2.1, FLUX.3 klein) are left out on purpose, and the 9B is in because it is the same model family a step up, with its licence shown wherever it is used. Each model's licence is in What Studio downloads, and its licences.

ComfyUI and its models go in ~/.sparehand/studio/comfyui, unless the machine has ~/ai: then in ~/ai/comfyui. Make ~/ai a link to a big drive to keep them off a small internal disk:

ln -s "/Volumes/My Drive/AI.noindex" ~/ai

(.noindex keeps Spotlight out of it.) When that drive isn't connected, nothing is downloaded to the internal disk instead, and a picture job says the drive is missing. Nothing is downloaded either when there isn't room for the models and 10 GB to spare. SPAREHAND_COMFY_HOME chooses another folder.

Then switch the tools on in Settings. Studio picks them like any other tool: with Local only, or the priority cheapest, they win; with balanced, the local pictures beat Gemini's (free, a little less detailed), and Gemini's clips beat the local ones; and with several makers there, the pictures are spread over them (below). You can always redo a picture or a clip with the other tool.

How it runs: the pictures are spread over every maker that can make them at once. A maker is a tool on a machine: ComfyUI pictures on each spare machine that is up and has its models, ComfyUI pictures on this computer when it is set up too (sparehand studio install hub --with pictures), Gemini images when its key is there. Each picture goes to the maker that would have it done soonest (the queue in front of it there, in seconds, plus its own), so a fast machine takes more than a slow one and a paid model takes a share when it cuts the wait; a maker whose queue is done takes a picture still waiting in the longest queue. A picture made from another scene's (its ref) goes to the same maker as that scene, so the faces match, and only to a maker that takes reference pictures (Z-Image Turbo doesn't). The production's priority says which makers may be used: cheapest and Local only the free ones on your machines; balanced those, with a paid model beside them only when it cuts the time by more than half; quality the tools the registry rates best; and the storyboard's Fastest / Free, on my machines / Cheapest choice overrides it. A picture tool chosen on the storyboard, or the brand kit's (when no choice was made under Made on), makes all of them: a kit that chose Gemini images doesn't have its pictures spread to ComfyUI because that is free, and none of them is taken over by another maker; a layered scene still goes to a maker that cuts people out. Studio keeps what each picture took on each maker, and after three uses the storyboard's "how long" is that measure instead of the registry's rough figure.

Candidates. A picture made free on your own machines (ComfyUI) is made as three candidates (different seeds, on the same maker in one job, so the reference pictures and the model are the same and the model is loaded once), and the Director picks the best with one look against a short checklist built from the scene: who is in it and how many (the brand kit's cast; a face in a window or a mirror counts as one too many), each person's look against their reference picture, the pose or action its lines and prompt ask for, no lettering, and the kit's style. FLUX.2 [klein] 4B often gets the number of people, who looks like whom and hands wrong, and from three seeds one is usually right; that is cheaper than remaking a picture one at a time from a new prompt. The number is Pictures on your machines … candidates of each in Studio → Settings (1 to 6; 1 turns it off). The storyboard's Where, and how long counts them ("ComfyUI pictures on myworker (3 candidates each)": a maker's seconds are for all of them), and the next picture waits in its maker's queue while the Director picks, so the card isn't idle. The others stay in the production's out/made/ (never copied to the machines), best first: Next candidate on a picture swaps in the next one, with what the Director saw wrong in it, before Redo makes new ones. A picture the layout or continuity check sends back is made the same way, and the Director is told what was wrong with the last one.

The picker is the production's Director when it can look at pictures and a call costs nothing (a Claude subscription, a model on this computer); else another Crew agent that can (for Local only, one on this computer). A Local only production directed by a local model can be judged by it: Gemma 4 (gemma4:26b in Ollama on the hub, as a Crew agent) has vision and sees the pictures through Crew (Claude Code reading the files, Ollama's Anthropic-compatible API), a few seconds a look; it counted the extra girl in a window that a picture of two sisters had. When no writer can see pictures, one picture is made, as before. Not on a paid machine (its hours cost), nor for a member who pays for the machine minutes; a command of your own makes candidates when it takes {count} (below). Nor with a paid picture model such as Gemini images: each candidate would be another picture paid for (three would be about $0.20 a scene), and given each person's own picture it got four people right on the first try where the 4B needed three seeds and remakes; a picture the layout or continuity check sends back isn't made again by itself with a paid tool: it waits for Remake for $X (see Continuity).

Each picture or clip on a machine is a sparehand run --gpu job (a clip with --whole too: the clip model takes most of the laptop's memory, so nothing runs beside it and the laptop doesn't swap), one at a time on each machine (two on one card would only wait for each other's memory), and different machines run at the same time. When the machine a picture was given goes down meanwhile, it goes to any other machine with the models. A clip waits for a machine with an NVIDIA card, up to half an hour: only that can make one; with more than one such machine the clips are spread the same way as the pictures. A paid machine, a cloud GPU worker (cloud-gpu.md: a Runpod pod made from Add a machine, or a Google Cloud VM) or a rented one with a price an hour (sparehand set NAME price), never gets a picture, a clip or any other step by itself, whatever the priority or the choice: tick it under Paid machines on the storyboard and it joins that production's makers (a cloud worker is started for its jobs and stopped after its idle time; a rented pod that is stopped is waited for, up to half an hour, and the storyboard says to start it), its minutes counted at its price in the cost. Studio doesn't set a paid machine up by itself either: sparehand studio install NAME --with pictures,clips does. If no machine was free by then, the scene keeps its picture, still, and says so. On a Mac with Apple silicon that downloads the full bf16 picture model (7.8 GB instead of 4), since a Mac's GPU can't compute in fp8. It is slower there: about 1.5 minutes a picture on an M4 Max (measured: 93 seconds, the first of a session 3.5 minutes). Clips need the NVIDIA card: --with clips on a Mac says so and downloads nothing. ComfyUI is installed at one commit, the last one measured with Studio's pictures and clips (pinned in kit/comfy.py and in the install script; a newer one can load models another way, and SPAREHAND_COMFY_REV=… moves it on purpose). The first job starts ComfyUI there, on 127.0.0.1 only. A production's clips get a ComfyUI of their own on each machine: it is started for the first one (a picture's ComfyUI is stopped for it), and kept running, the clip model loaded, while that production has more clips for that machine, so the next clip starts in it instead of in a fresh one (see Clips without the wait). It is stopped after the production's last clip there, when a picture or another production's clip comes, or after 3 idle minutes: a ComfyUI process keeps the memory it once used even after freeing its models, and the 14B model's two halves live in the machine's memory (they don't fit on an 8 GB card), so another job starting on top of it sent an 8 GB laptop deep into swap. A picture's model stays loaded for the next picture (loading it again took a minute and a half of each picture's three minutes on the laptop) and leaves memory after 2 idle minutes. Studio makes every picture first, a clip scene's own picture too, and then the clips, and pictures and clips have queues of their own on each machine: while a clip has the laptop to itself, pictures go to another maker (this computer, Gemini) rather than wait. ComfyUI itself stops after 10 idle minutes, so a game started afterwards gets the whole card. When a job is stopped (you stop the production, or Sparehand's watchdog stops it), it is cancelled in ComfyUI too, so the card is let go at once. When ComfyUI dies while it makes something (its process gone, its port no longer answering) or stays silent for 5 minutes, the job ends within seconds with the last lines of its server.log, and Studio tries it once more in a new ComfyUI; a job that runs past half an hour (a picture) or two hours (a clip), far longer than any measured, is taken for a hung ComfyUI and ends the same way (SPAREHAND_COMFY_MAX_WAIT, in seconds, changes the limit). Once a ComfyUI on a rented card vanished without a word while loading a model, and the picture waiting on it held that machine's whole queue for 53 minutes.

On an RTX 4060 laptop GPU (8 GB), measured: a picture takes 15 to 22 seconds (1360×768; the first of a session about 30, with ComfyUI starting; measured again later: 22 to 38 s with its models loaded, but the first of a session 8 minutes that day, see below), and a 5-second clip at 1280×704 takes 18 to 24 minutes (20 steps of 30 to 45 seconds each, slower as the laptop heats up, then a minute or two to decode). The clip model is the fp8 one: it leaves the laptop 7 GB more memory than fp16 (which came close to the point where Sparehand stops a job for low memory). Its clip took 24 minutes and the fp16 one 18, but the fp8 run started on a GPU still hot from the first, so that difference is partly heat. A production with three clips takes an hour longer, but costs nothing; "sizes" below makes clips faster.

The 14B on the same laptop, the same 5-second clip (same picture, prompt and seed): 5.3 minutes at 832×480 (4 steps of 67 seconds, two per expert, then the decode), the GPU at up to 81 °C. Memory stayed at 22% free or more, clear of the 8% where Sparehand stops a job. At 1280×704 it doesn't fit the card: the whole model is moved to the GPU piece by piece for every step, a step took 21 minutes (a clip would take about 85), and memory dropped to 6% free for a moment when it switched experts. So the 14B makes 832×480 whatever the size asked for on a card under 16 GB.

Bigger cards, bigger models. Studio chooses the model per machine: the registry's byVram list on each ComfyUI tool ([[16, "flux2-klein-9b"], [7, "flux2-klein-9b"], [0, "flux2-klein-4b"]] for pictures, the 8 GB entry for a card with 24 GB of memory, which its install checks; [[16, "wan2.2-i2v-14b-q8"], [7, "wan2.2-i2v-14b-q8"], [7, "wan2.2-i2v-14b-q6"], [0, "wan2.2-i2v-14b"]] for clips, the 8 GB Q8 for a machine with 30 GB of memory, which its install checks, else the Q6) says which model a machine with at least that much card memory uses when it has that model's set (sparehand studio status shows the card's vram and the sets), and the tool's own model otherwise; so a picture sent to a 24 GB machine with pictures9b is made with the 9B while the same production's pictures on an 8 GB laptop without it are made with the 4B. The tiers apply only while the tool's model is one the list names (the 4B for pictures, the Q4 14B for clips): a model you picked by hand that the list doesn't name, Z-Image Turbo or the 5B say, is used everywhere. The storyboard's Where, and how long line names the model on each maker where it differs from the tool's, with the licence note ("ComfyUI pictures (flux2-klein-9b, non-commercial licence) on runpod (4)"), the same under Paid machines, and the note under the lines says which models are under a non-commercial licence; each made picture or clip says the model it was made with, and the time each maker is given is measured per model. Members' productions never get a model under a non-commercial licence, not even on a paid machine you gave them: the 9B's machine makes their pictures with the 4B. When you approve a member's request there is a box, Allow the models under a non-commercial licence for this production; tick it and that production may use them, which the production's events and the storyboard's note say. With the 9B chosen as the pictures model outright, the tool isn't available to members at all, and their tool list says why. The sizes a clip model makes on a bigger card (BIG_SIZE in kit/comfy.py) are only those measured on one: a model not measured there keeps its 480p cap on every card.

Measured (2026-10-28) on a laptop RTX 4060 (8 GB on the card, 25 GB of memory, WSL2). Pictures (FLUX.2 [klein] 4B, fp8, four steps): 38 seconds with four people's pictures at 1360×768; with a kit's LoRA and the room's picture 16 seconds at 1360×768 and 26 at 1920×1088, the size Studio now asks for (crisper at the video's own size; eight steps added sketchy texture, not quality, at 28 seconds; the 4B's full bf16 weights looked the same as fp8). A 5-second clip from the 14B: Q4_K_S at four steps 5.7 minutes; at eight steps 10; Q5_K_M 6.3 and Q6_K 6.2 at four steps, with crisper lines and eyes (20 of the 25 GB of memory in use); Q4_K_S at 960×544 8 minutes for little more detail; Real-ESRGAN to 1080p 36 to 40 seconds more a clip. So a machine with an 8 GB card and the clips14b-q6 set makes its clips in Q6_K at eight steps (10 minutes; crisper, steady faces, and the motion asked for done more often), and with Clips in 1080p about 11 minutes a clip: a 60-second episode of 7 scenes (3 candidates of each picture, 7 clips) takes about 1 hour 26 minutes there, against 53 minutes before; one in close shots (4 clips at most) about 55. A bigger picture model doesn't pay on 8 GB: Qwen-Image-Edit would swap a 12 GB GGUF through memory, at minutes a picture.

Measured (2026-10-25), the 14B in Q8 on a rented A40 (46 GB). Seven 5-second clips at 832×480 took 143 to 277 seconds each (about 25 minutes for all seven, about $0.25 of the pod at $0.59 an hour); one at 1280×704 took 325 seconds, about a fifth longer, and is clearly sharper. So on a card with 40 GB or more (HD_VRAM) the Q8 makes its clips at 1280×704 (BIG_SIZE); on a 16 GB card it keeps 832×480, since a Q8 expert leaves little room there for 720p's frames. The storyboard's rough figure for a Q8 clip is 300 seconds (roughSecondsBy) until Studio has made three on that maker. The 9B picture model on a laptop RTX 4060 (8 GB card, 31 GB of memory, native Linux, 2026-11-05): 10 to 18 seconds a picture at 1360×768 against 6 to 8 for the 4B, with 22 GB of memory still free; it spelled a sign's word right in both pictures where the 4B did in one of two. Its rough figure stays 40 seconds a picture at the video's own size until Studio has measured it on a maker. On the same laptop (2026-11-06) the same 5-second 832×480 clip from the same picture and seed took 626 seconds with the Q6 (eight steps) and 347 with the Q8 (four), about as good (the Q8 a touch crisper), with 5.4 and 5.3 GB of the 31 still free at the least: so the Q8 is the laptop's clip model, and it needs 30 GB of memory. For the record, on a rented RTX A5000 (24 GB): a 4B picture 6 seconds warm, 24 cold (plus 90 seconds for ComfyUI to start), and a Q4 14B 3-second clip 174 seconds (plus 80 to load the model). The two bigger sets need about 49 GB (the 9B with its text encoder 18 GB, the Q8 experts 31 GB) plus the install's 10 GB reserve; the install says how much a volume has to grow and grows nothing.

When a picture takes minutes instead. On 2026-10-20 every picture on that laptop took 240 to 570 seconds, on the same ComfyUI and models as the day before. Two things were found. A Chatterbox voice job on the same card holds WSL's path to the card, so a picture's model loading waits for it: pictures made beside a voice job took 350 to 580 s, and a voice job of 5 seconds made the next picture reload its model (54 s instead of 22). Studio now makes voices in the pictures' turn, one GPU job at a time on a machine. The rest is the laptop's host-to-card memory path itself: with no voice job, a picture takes 22 to 38 s once the models are loaded, but loading them (ComfyUI's first picture after it starts, which happens after 10 idle minutes and after every clip) took 475 to 490 s instead of 30, and copying memory to the card ran about ten times slower than the card's PCIe link allows, on a freshly restarted WSL too. No flag of ComfyUI's loader helps: tried one at a time, the older loader (--disable-dynamic-vram) gave 268 s cold and 70 to 84 s a picture after that, pinned memory off 338 s and 42 to 52 s, so ComfyUI's own dynamic loader stays (SPAREHAND_COMFY_ARGS adds flags for trying another). What to look at is on the Windows side of that laptop (the NVIDIA driver, a power or performance mode, what else holds the card). On a machine, python3 kit/comfy.py doctor (in a production's folder there, or lib/studio/comfy.py doctor in Sparehand's checkout) shows its ComfyUI commit against the pinned one and the flags it is started with, so a change there is visible.

In ~/.config/sparehand/studio.json, under tools:

• "comfy-image": { "runs": "hub" } makes pictures on this computer, never on a spare machine.
• "sizes": { "16:9": [960, 544], "9:16": [544, 960] } makes smaller pictures or clips (a clip has about half the pixels at 960×544, so it takes about half the time; the video is scaled up to 1080p).
• "byVram": [[16, "flux2-klein-9b"], [0, "flux2-klein-4b"]] is the model per card size (above); "byVram": [] makes every machine use the tool's model. "roughSecondsBy" gives each model its rough seconds a picture or a clip until Studio has measured three on that maker.
• "model": "/Users/you/workflows/my-model.json" uses another model: a workflow exported from ComfyUI with Export (API), its strings "{prompt}", "{ref}", "{image}", "{width}", "{height}", "{frames}" and "{seed}" filled in. The models it needs must be in ComfyUI's models folder on that machine.
• "command" can be any program that writes {out}: {prompt}, {model}, {width}, {height}, {seconds}, and {ref} or {image} (one argument per picture, left out with the flag before them when there is none). With {count} it makes that many candidates of a picture in one run, written as {out} and then {out} with -2, -3… before its extension (kit/comfy.py image --count N); without it, one.

To use a ComfyUI you already run, set SPAREHAND_COMFY_URL (say http://127.0.0.1:8188) in that machine's ~/.sparehand/env (on this computer, in the dashboard's environment).

A Windows PC that got slow

When pictures on a Windows PC (WSL) suddenly take 5 to 10 minutes instead of 20 seconds, with Model Initializing taking most of it, the PC's GPU bridge has degraded: WSL's path from memory to the card has dropped from about 8 GB/s to 0.1, which happens after a few days up, and only a Windows restart heals it (see Adding a worker, A degraded GPU bridge). Sparehand measures that path on every Linux and WSL machine with an NVIDIA card, at most every 10 minutes, and a machine under 1 GB/s gets no picture or clip (its card shows GPU bridge degraded, 0.10 GB/s, restart Windows, with a notification): the work goes to the other makers meanwhile. sparehand studio status shows the numbers for each machine (h2d_gbs to the card, d2d_gbs on it, dxg_errors from its kernel log; a healthy laptop read 9.45 and 88), and so does python3 kit/comfy.py doctor there. Set the PC to heal itself with sparehand set NAME heal auto (Machines → Edit): it restarts Windows once nobody has used it for 10 minutes and no job runs there, at most once in 6 hours, and the Activity tab logs the speed before and after; with the default ask, press Restart Windows now on its card instead.

Music and sound effects

A video can have music under the whole of it and sound effects at its moments (a whoosh as a title lands, a camera shutter, rain), without you supplying any files.

How the Director chooses: when it plans the storyboard (or the cut list of your footage), it picks the music for the production: a mood ("warm, hopeful"), a genre and its instruments ("soft acoustic guitar"), a tempo and a search for a music library. It can also say none, when a video is better without music (a serious subject, a talk that must be heard clearly). It may add a few sound effects to a scene, each with a cue like the scenes' own ("2:word": when line 2 says that word; "1": when line 1 starts; a number: seconds into the scene) and a description, at most three a scene and a few in the whole video:

"sfx": [{ "at": "1:click", "text": "a soft mouse click", "volume": 0.5 }]

Where they come from:

• Music made with AI: Google's Lyria with the Gemini API key you already have (Lyria needs billing on the key: about $0.04 for a 30-second piece that loops under the video, or $0.08 for a whole piece with lyria-3-pro-preview, chosen on its card in Settings → Tools), or ElevenLabs music with the ElevenLabs key (it needs a paid ElevenLabs plan; the piece is made as long as the video).
• Sound effects made with AI: ElevenLabs sound effects, with the ElevenLabs key Studio already has (a few cents of your plan's credits each).
• Found: Freesound (freesound.org) has music and sounds; Studio only takes those whose licence allows them in a video (CC0, or CC BY), and credits each in the YouTube text as the licence asks (its title, who made it, the licence and its page). Get a free key at freesound.org/apiv2/apply once signed in, and enter it under Studio → Settings → Freesound API key (or sparehand studio key freesound). Pixabay's and Pexels' APIs have no music or sounds.

Studio picks the tool for your priority (Cheapest takes Freesound when its key is there) and shows the cost of the made ones in the estimate. The YouTube text says when the music or some sounds were made with AI.

They are fetched with the storyboard, like the pictures: Music and sound on the storyboard plays each one, with the mood the Director picked. Redo gives the next match (or a new piece), Redo with these notes searches for the notes or says what to change ("slower, no drums"), and Other music, or none changes the mood or turns the music off. Editing a scene's sfx fetches its sounds again. A sound effect its tool won't make (ElevenLabs refuses some, or is at a limit) is looked for on Freesound instead, when Freesound can be used. A sound that still can't be found or made is marked needs your eyes, and the video goes on without it.

In the video: the music loops under the voice, is turned down while someone speaks and fades out at the end; each sound effect plays at its moment, quieter while someone speaks; everything is at YouTube's loudness (-14 LUFS). Changing a sound, its moment or its volume only mixes the sound again: no scene is rendered again. With your own footage the music and the effects go under the footage's own sound and the new voice, on the cuts and the cards alike.

Your own music always wins: start a production with --music FILE (or the form's Music field, or attach an audio file to a footage recipe that takes music) and the Director doesn't pick any. The sound effects still come from the tools.

No music at all: choose Music → No music on the form (or --no-music) before the Director plans it. The Director is told the video has none (no instrumental music, no songs), the storyboard's music is none, and no music is found, made or paid for: the estimate says Music: none. Sound effects and soft natural sounds are still allowed unless you say otherwise in the description. You can still add music on the video's page later (Add music). For a channel that must never have music (a children's faith series, say), set its brand kit's Music to Never (see Brand kits): every video with that kit starts with no music, the form shows No music and won't change it, and music can't be added on the video's page either. No music can't go with your own music file: choose one or the other.

Vertical videos

Choose Vertical 9:16 under Format (or --format 9:16) for YouTube Shorts, Instagram Reels and TikTok. The video is 1080×1920 and the scenes are laid out for a tall stage: cards, machines and the two numbers of a comparison stack in one column, a logo sits above its name, and a screenshot fills the width. The Director is told the stage is narrow, so it keeps on-screen text short and hooks the viewer in the first two seconds. The layout check draws every scene at the real size, so text that doesn't fit goes back to the Director as it does for landscape. The thumbnail is a tall cover, and the YouTube text has no chapters (Shorts don't show them).

Your own footage

Studio can also work with videos you shot. Pick one of these recipes, then choose Your footage: a video file, or a folder of videos, on this computer (Browse…, or type its path). Short clips can be attached instead. The footage is only read, never changed.

How it runs:

1. Studio looks at the footage. ffmpeg on this computer reads each clip (its length, size and sound) and takes key frames from it. Whisper, on a spare machine, writes down what is said and when, and works out the language. Without Whisper, Studio finds where people speak from the loudness, and the Director cuts by that instead. While Whisper listens, Studio says about how long it will take and until when.
2. The Director plans a cut list. It looks at the key frames, reads the transcript and plans the cuts: which piece of which clip, in what order, and what is said over each one. It can add short title cards between the cuts. Studio checks the list: a cut outside its clip, a line outside its cut, an edit far longer than you asked for, a list with no cuts of the footage, a picture or video scene of its own between the cuts, or cards that take longer than the cuts go back to the Director. A list that still has no cut of the footage after its tries stops there, with nothing to approve. With Local only, a model on your machines plans it, and a small one can't read a long talk: when the transcript is longer than about 16,000 characters (some 17 minutes of talk), Studio stops before planning and says so. Untick Local only for long footage.
3. You approve it, as with a storyboard. Each cut shows its clip, its times and a frame. You can change a cut's times under The cut, edit the lines, or remove a cut. It says what it will cost and about how many minutes cutting and joining will take.
4. Studio makes it. Each cut is made once, on this computer, in the format you chose (16:9 for YouTube, 9:16 for Shorts, Reels and TikTok, or 1:1). A clip of another shape is fitted whole, with bars. The cuts and cards are joined, the footage's own sound goes under the new voice and the music (the music gets quieter while someone speaks), and it all ends up at YouTube's loudness. The captions are the words said, at their place in the edit, in every language you ask for. When there are no cards to draw, the thumbnail is a frame of the footage.

Change a cut, and only that cut is made again.

How long it takes: the times are rough at first. Studio learns how fast Whisper and ffmpeg are on your machines from each video it makes, so the times get closer after a few.

Music: give an audio file (Music, --music FILE, or attach it). It plays under the whole video, loops if it's short and fades out at the end. Music works for the other recipes too.

Wide footage in a vertical video

When a landscape clip goes into a 9:16 (or 1:1) video, Studio crops it to the person instead of showing it small with bars. On this computer, OpenCV finds the face every quarter of a second, and the crop glides after it. Where no face is found, the crop stays where the Director said the subject is, or in the middle. Choose it under Wide footage on the form (or --reframe):

• follow the face (smart, the default)
• crop the middle (center)
• show it whole, with bars (bars)

sparehand studio install hub installs OpenCV (in Studio's private Python, for your user only).

B-roll

B-roll is what makes a long talk or tutorial look edited: while the speaker talks about something, the picture cuts away to it (a stock video, or a picture), their voice going on underneath, and a few seconds later it cuts back to them. Tighten my video, Montage from your footage, Narrate your footage and Highlight clips add some by themselves when a stock library or an image model is set up (see Real pictures). Dub, Change the voice and Change the person have none: the person on screen is the point there.

• How much: B-roll under Options (or --broll): none, some (the default: one cutaway every 20 to 30 seconds of talk, where it fits) or lots (wherever the words name something showable, about one every 10 to 15 seconds).
• Where: the Director puts a cutaway only where the words name something a picture can show ("we knead the dough" → a stock video of kneading dough), at the moment it is said. Studio checks each one: inside its cut, not over the cut's first 1.5 seconds, 1.5 to 8 seconds long, one at a time, and the speaker on screen for most of the cut. Anything else goes back to the Director.
• The pictures are found in the background while the cut list waits for your approval, so you read it as soon as the Director is done and see them as they arrive: each cut shows its B-roll with its times in the clip. A search finds a stock video (a photo when there is no video for it); a picture to make is made with AI. Redo finds another one, Redo with these notes searches for what you write. A cutaway nothing was found for leaves the cut on the speaker there, and is marked needs your eyes under Pictures. Edit a cut's broll under The cut to move, change or remove one.
• How it looks: the cutaway fills the frame (cropped to the format), a still picture slowly zooms or pans (move: in, out, pan-left, pan-right), and it fades in and out over a third of a second. The cut's own sound plays on underneath, and the captions stay on top. Changing a cut's B-roll makes only that cut again.
• Credits: the stock creators are thanked in the YouTube text, and the estimate says how many pictures come from where.

Highlight clips

Highlight clips turns one long video into several short ones, for YouTube Shorts, Instagram Reels and TikTok. The Director finds the moments that stand on their own and grab attention in the first two seconds. It tightens each one, and gives it a title that's a hook. Ask for a number of clips in the description ("five clips"); otherwise it makes 3 to 5. Length is how long each clip should be. Each clip comes out as its own vertical video, with its own captions (drawn in), thumbnail, post text and YouTube upload.

Summary of a long video

Summary of a long video cuts a talk, a lecture, a meeting or a podcast down to its main points. The Director finds each point and keeps the passage where it is said most clearly, tightened (no pauses, filler words or false starts), in the order it comes in the video. Each part gets a short heading card, and the summary opens on a title card. Length is how long the whole summary should be (3 minutes unless you say otherwise); say in the description what matters most to you ("the decisions and who does what", "skip the Q&A"). It has no music (the talk is the point), and B-roll as for the other footage recipes.

Another voice

A dub keeps the whole video. Each sentence of the original is translated and said by the voice you choose, at the moment the original was said. A line that runs longer than the original is said a little faster to fit (up to 30% faster). If it's still too long, it's marked needs your eyes so you can shorten it.

Change the voice keeps every word. With a voice changer it says each sentence again in the new voice, keeping its timing and feeling. Without one, a new voice says the words from the transcript.

• ElevenLabs voice changer uses your ElevenLabs key. Set the voice ID for the language under the production's voice (tool elevenlabs-sts).
• A voice changer command on this computer (RVC, or anything that turns one WAV into another): set its command in studio.json (see Command tools).

To keep the music and room under the new voice, Studio first takes the voice out of the footage with Demucs on a spare machine. Demucs is large (it brings PyTorch), so it's only installed when you ask for it:

sparehand studio install NAME --with demucs

Without Demucs, the footage's own sound is kept very quiet under the new voice.

Lip-sync: a dub can also move the mouths to match the new voice, cut by cut, with a lip-sync model you set up (tool lipsync-command; Wav2Lip, LatentSync…). Without one, the mouths keep their original movement.

Another person

Change the person puts the face in a photo you attach on the person in the video, with a face model you set up (tool face-command; FaceFusion, for example). Everything they say and do stays the same.

Permission

Changing how a real person sounds or looks needs their permission. Studio asks you to confirm it before a dub, Change the voice or Change the person starts: it's your own voice or face, or the person has agreed (for a new face, both the person in the video and the person in the photo). Your confirmation is kept with the production. Don't use these recipes to make someone appear to say or do something they didn't.

Command tools

The voice changer, lip-sync and face tools are programs you install yourself. They are off until you set them up in ~/.config/sparehand/studio.json, under tools: switch the tool on, and give its command and the folder it runs in. These are only set in the file, never from the dashboard. Studio fills in {video}, {audio}, {face}, {in}, {out} and {voice} with full paths:

"tools": {
  "lipsync-command": { "on": true, "cwd": "/Users/you/Wav2Lip",
    "command": ["python3", "inference.py", "--checkpoint_path", "checkpoints/wav2lip_gan.pth", "--face", "{video}", "--audio", "{audio}", "--outfile", "{out}"] },
  "face-command": { "on": true, "cwd": "/Users/you/facefusion",
    "command": ["python3", "facefusion.py", "headless-run", "--source-paths", "{face}", "--target-path", "{video}", "--output-path", "{out}"] }
}

With "runs": "worker", the tool runs on a spare machine instead (one with a GPU, say). The files go with the job, the paths are relative to the job's folder there, and the tool must be installed on that machine.

Repurpose a video

Repurpose a video (Studio → Repurpose a video) takes one long real video, or a few, and makes everything you'd post from it out of one transcript: the transcript itself, captions, shorts, chapters, a summary and dubbed versions. You pick what you want from a checklist. Each item shows how long it will take on the machine you chose. The times are rough until Studio has run that item on your machines once; after that they come from what it measured.

• Your video: a file or a folder of videos on this Mac, one a line (up to 8). They are only read, never changed.
• Language spoken: a code like en or tr. Leave it empty and Whisper works it out.
• Speakers: found by voice, or one person.
• Machine: the least busy one (a machine with an NVIDIA card first), or one you choose.
• Director: the usual one, or a local one (a model on your own machines, in Crew).

The transcript

Whisper transcribes the video on a spare machine (the NVIDIA card when one is free). Then a small voice model works out who speaks when: Chatterbox's voice encoder, which comes with the local voices, or a rougher sound-based grouping where it isn't installed. Each sentence gets its time and its speaker, and you can edit it on the page:

• Click a sentence and fix its words. Words you don't change keep their exact times.
• Fix everywhere changes a word in every sentence that says it ("Sparhand" → "Sparehand").
• Rename the speakers, or set the speaker of one sentence.

Every output is made from the transcript as it is when you make it. Once you edit, anything made before says made from an earlier transcript with a Make again button. Only the edited sentences are translated again.

What it makes

• Captions: .srt and .vtt in the spoken language and in each language you list (the Director translates them, as natural spoken lines). With several speakers, each new speaker's line starts with their name. You can also have them drawn into the picture in up to three styles: Bold (a few big words, each lit as it is said), Clean (the whole line on a dark box) and Minimal. Drawing them needs an ffmpeg with libass (brew install ffmpeg-full). Without it you still get the files.
• Chapters: start times and short titles for the video's description. The first starts at 0:00, there are at least three, and each is at least 10 seconds long (YouTube's rules).
• Shorts: the Director reads the transcript and proposes moments that work on their own. Each one opens on a hook, is one complete thought and fits the length range you set. Each comes with a title, a description, why it works, and a score from 1 to 10. Tick the ones you want and press Make the ticked shorts. Each short is cut vertical (1080×1920) and follows the face of the person speaking, smoothed so the frame glides; when no face is found it stays in the middle. Pauses and filler words (um, uh…) are taken out, and large captions are drawn in. Its title and description are in a text file beside it.
• Summary: the Summary of a long video recipe, started as a production of its own from this transcript, with your edits (it isn't transcribed again). Its cut list waits for you in the list of productions as usual.
• Dubbed versions: each sentence is translated, said by a local voice (Chatterbox, on a machine with an NVIDIA card) at the moment of the original sentence, and mixed over the original music and sound. A line longer than its moment is said up to 30% faster. If it's still too long, it pushes the next line on by up to 0.6 seconds and is listed under needs your eyes. Once the speakers are heard, choose each one's voice: Chatterbox's own voice, a voice sample of one of your brand kits, or the speaker's own voice copied from the video. Copying a real person's voice needs their consent: it can only be chosen once you tick the box that says you have it (off by default). To keep the music and room, Studio takes the voice out of the original with Demucs (sparehand studio install NAME --with demucs). Without it, the original is kept quiet under the new voice. A dubbed version also comes with captions in its language. No lip sync: the picture is the original, so the mouths don't move to the new words.

Long videos

A long video is worked on in pieces of about ten minutes, cut at its pauses, so no word is split. Its sound is read once and cut into pieces. Whisper, the voice removal, the voices and the mixing each work on one piece at a time, so a two-hour video never has to fit in memory. Each finished piece is kept, and the page shows how many are done. Stop, a failure or a restart of the dashboard loses at most the piece being worked on, and Resume carries on from the next one.

What stays on your machines

Whisper, the speakers, the voices, the voice removal, the face finder and ffmpeg all run on your own machines, so the video and its sound never leave them. Only the Director reads text: the transcript, for the translations, chapters, shorts and the summary's plan. With a local Director nothing leaves your machines at all. With a cloud Director the form says which service gets the transcript, and for which items. Tick Private and everything is erased 10 minutes after you've downloaded all of it, or a day after it was last touched, from this Mac and from the spare machines it ran on. A private one's Director keeps no record of the calls either.

Repurposing is for the owner of the dashboard; members can't use it yet.

Captions in the picture

Tick Captions drawn into the video (or --burn-captions) and the captions are drawn into the picture. They show a few words at a time, low in the frame (higher in a vertical video, above the apps' buttons), in the brand kit's font, and each word lights up in its accent colour as it is said. It's on by default for vertical videos and highlight clips, because most people watch those without sound. The plain video is kept beside it, and the .srt is made either way. ffmpeg draws them with libass. Homebrew's ffmpeg hasn't had it since 2025, so install brew install ffmpeg-full: Studio finds it by itself. Without it, the step says so once and the captions stay a file. You can switch it on or off on a finished production, and only the captions are made again.

Upload to YouTube

Studio can upload the finished videos to your channel. It sends the title, the description with its chapters, the captions and, for a landscape video, the thumbnail. Highlight clips are uploaded one by one. Videos go up as private unless you choose unlisted or public.

A Short or a regular video

YouTube decides what is a Short by itself, from the video's shape and length: every vertical or square video of 3 minutes or less becomes a Short, and the upload has no switch to change that. So for a vertical or square video the upload box has Upload as (from the terminal, --as, or --short and --video):

• Short or video: by its length (auto, the usual): it goes up as it is, and YouTube decides.
• As a Short (short): Studio checks that it qualifies (vertical or square, 3 minutes or less) and refuses one that doesn't, saying why, and adds #Shorts to the description.
• As a regular video (video): Studio first fits it into a 16:9 frame, the picture whole in the middle and a blurred, darker copy of it filling the sides, so YouTube shows it with the other videos, in search and on the channel's Videos tab. The fitted copy is kept beside the video (…-16x9.mp4) and used again next time.

A landscape video is always a regular video, so it has no such choice. A production remembers what it last went up as.

Made for kids, and altered or synthetic content

Every upload tells YouTube two things, which the upload box shows before you upload and lets you change:

• Made for kids (selfDeclaredMadeForKids in the YouTube Data API). It comes from the brand kit's Audience (see Brand kits): a kit made for kids uploads every video of it as made for kids, a kit set to ask has no default and won't upload until you choose. A video without a kit is uploaded as not made for kids. From the terminal, --made-for-kids or --not-for-kids. YouTube requires videos made for children to be marked so (COPPA), and turns off comments, personalised ads and some other features on them.
• Altered or synthetic content (containsSyntheticMedia). It is on when any step of the production made a picture, a clip or a voice with AI (made pictures, Gemini or ComfyUI clips, a text-to-speech voice, a changed voice or face, lip-sync); the box says which. A video only of your own footage, voice and stock photos has it off. YouTube asks for realistic altered or synthetic content to be declared; clearly unrealistic content such as cartoons doesn't need it, so you can switch it off. From the terminal, --synthetic or --no-synthetic.

Studio always sends both values, so they are set on each video. YouTube's help says a video's own setting overrides the channel's: setting the whole channel as made for kids in YouTube Studio (Settings → Channel → Advanced settings → Audience) doesn't change a video that was uploaded as not made for kids. For a children's channel, set its brand kit's audience to made for kids, and fix videos uploaded before in YouTube Studio (the video's Details → Audience).

Signing in with a code (a TVs and Limited Input devices client) can't add captions: YouTube doesn't allow it. Sparehand says so, leaves the upload marked done, and keeps the .srt in the output folder: add it under Subtitles in YouTube Studio. Signing in with the browser (a Desktop app client) can add them.

Connect your channel once:

1. In the Google Cloud console, make a project, switch on the YouTube Data API v3, and under Credentials make an OAuth client ID of the type Desktop app (captions work) or TVs and Limited Input devices (a code, no captions). While the app is in testing, add your Google account as a test user on the OAuth consent screen.
2. Paste its client ID and secret under Studio → Settings → YouTube, and choose Sign in with browser (Desktop app) or Use a code (TVs; also sparehand studio youtube connect).
3. With the browser, allow access to your channel on Google's page: it sends you back to the dashboard, so open the dashboard on this computer (http://127.0.0.1:PORT). With the code, open google.com/device on any device (your phone works) and enter the code Studio shows.

The sign-in is kept in the Keychain (or, on Linux, in ~/.config/sparehand/studio-youtube.json, readable only by you). Then Upload to YouTube on a finished production (or sparehand studio upload ID --privacy unlisted [--as auto|short|video] [--made-for-kids|--not-for-kids] [--synthetic|--no-synthetic]) uploads it, and the links show up with its files. An earlier version can go up instead of the latest: Upload this one to YouTube under Earlier versions in its files (or sparehand studio upload ID --lang en --earlier 1, 1 being the one before the latest). YouTube allows a channel only a few uploads a day through the API until you ask Google for more. A custom thumbnail needs a verified channel.

When an upload fails with "the saved sign-in has expired or was withdrawn at Google", connect that channel again. Google ends a sign-in after 7 days while your Google Cloud app is in Testing (publish the app on its OAuth consent screen to keep it), when you change the account's password, or when you remove the app's access in the Google account.

Several channels

Each sign-in reaches one channel, so connect each channel once: Add another channel under Studio → Settings → YouTube (or sparehand studio youtube connect again) signs in with the same Google Cloud app, and on Google's page you pick the channel, a brand channel under the account that manages it. With more than one connected, the upload box has a channel picker (or sparehand studio upload ID --channel "My Channel", by name or channel id). A production remembers the channel it went to, and Redo of its upload goes there again. Remove next to a channel (or sparehand studio youtube disconnect "My Channel") forgets only that one; sparehand studio youtube status lists them. While more than one is connected, a disconnect that names none is refused with the list of channels, so it can't forget them all by mistake; sparehand studio youtube disconnect --all forgets every one.

Playlists

A video made in several languages can go up one language at a time: pick the language in the upload box (or --lang ar), so each can go to its own playlist. The playlist is remembered per language, so the next upload of that language picks it again.

The upload box also lists the chosen channel's playlists: pick one and each uploaded video is added to the end of it (No playlist leaves them out). From the terminal, sparehand studio youtube playlists [CHANNEL] lists them and sparehand studio upload ID --playlist "Tutorials" (its name or id) adds the videos to it. Redo of an upload adds it to the same playlist again. Make new playlists in YouTube Studio; they show up the next time you open the production. A private playlist works too.

A promotion plan

Studio → Promotion plans plans which videos go out on a brand's channel, and when. A plan belongs to a brand kit: pick the kit, then the days and time its videos go out (Tuesdays and Fridays at 18:00, say), how many days before each date to remind you (3 by default), what each video is (the recipe, landscape or vertical, its length and languages) and where it is shared: one of your connected channels, public on its date (or unlisted, or private for you to publish), or nowhere, when you share the files yourself.

The first time, Studio asks whether you have a schedule already:

• Suggest a plan for me: the Director suggests a video for each of the next dates (8 by default), from the brand kit, the videos made with it before and what you want from them ("more subscribers before the launch"). Each has a title, what to make and why on that date.
• I have a schedule: paste it in any shape (a list, a table, rows from a spreadsheet or a calendar) and the Director reads it into the plan. A video without a time gets the plan's time; lines it couldn't place are listed.

Either way you check what it made: Approve each video (or Approve all suggested), edit its date, title or brief, or remove it. New suggestions replace the ones you haven't approved yet. You can also add a video by hand.

Then, for each video:

1. A reminder comes to your phone (and every device with notifications on) the set number of days before its date: time to make it.
2. You approve it: Make it now starts its production with the brand kit, and its storyboard waits for your approval as usual. Or pick Use a finished video for one you made already.
3. Made: another notification asks you to approve sharing it. Approve sharing uploads it to the plan's channel as a private video that YouTube makes public on its date (publishAt), with its captions and thumbnail. When the date has passed, or is less than 15 minutes away, it goes up public at once. A kit that asks at every upload whether it's made for kids asks here too.
4. Shared: the plan shows its links and the date it goes public.

If a video still isn't shared the day before its date, one last notification says where it stands. Each reminder comes once; changing a video's date starts its reminders again. The plan is kept with the brand kit in studio.json, and the reminders are checked every minute while the dashboard runs.

A series

A brand kit whose videos are episodes (a children's cartoon, a weekly tutorial) can be run as a series: Studio → Series. Pick the kit; the page has four parts.

Memory

Studio keeps what the series is so far, and the Director gets it every time it plans a video of the kit:

• the premise: what the series is, for whom, what every episode does
• the people: each one's character and how they speak (taken first from the kit's voices)
• the recurring places (the kit's own places first) and running jokes
• every finished episode: its title, what happened, who appeared, new people or places it brought in, its topic and its lesson

The first time you open the page it is filled from the kit's finished productions, at once from their storyboards (a production made before the kit existed counts when it was made in the kit's folder or its title starts with the kit's name; one made twice under the same title counts once). Read the episodes again has the Director read every episode's script and write the memory properly: the premise, the characters, the jokes and each episode's record. From then on, each finished video of the kit is added by itself, and the Director writes its record and adds anything new it brought (someone new, a new place, a new joke). Edit any of it on the page; what you edited stays when the Director reads the episodes again. Remove from the memory drops an episode (its production stays).

When the Director plans an episode it is told the memory and three rules: don't make it about the topic or lesson of one of the last five episodes (unless your request asks for it), keep every person as the memory describes them, and refer back to an earlier episode where it fits (a callback, a running joke), never as a recap. A private production gets the memory too, but never goes into it.

Ideas

The series' list of episodes to make. Type an idea (what happens, who is in it, the lesson), or Suggest ten: the Director suggests ten from the memory and the channel's numbers, none the same as an episode made or an idea listed. Drag them into order, or use the arrows and Next; Make it now starts one at once, Skip keeps it but passes it over.

Schedule

Make an episode on the days and at the time you choose ("Thursdays at 10:00"): the first idea that waits becomes a production with the kit, in the recipe, length, languages and format of the kit's last episode unless you choose others, made on the machines you pick (the kit's choice, Automatic, one machine; or Local only). Its storyboard waits for you, and a notification comes to your phone and Mac (Episode ready to approve). Approve it as any storyboard.

Make it through to the finished video (I trust it) approves the storyboard by itself when it costs at most the series' spend cap per episode, and the episode never spends past that cap without asking (as any production past its limit: see What a production may spend). A storyboard that costs more waits for you, and the notification says why.

The queue never starts an episode while another production is being planned or made, nor while its last episode still waits for your approval: it waits (the page says for what) and starts once it can. It never uploads: you upload the finished episode, or give it to a promotion plan, which shares it once you approve. The schedule, the ideas and the time of the next episode are kept in the series' file, so a restart of the dashboard loses nothing; an episode due while the dashboard was off starts once it is back.

Episodes and their numbers

Each episode on YouTube shows its views, and with statistics allowed its average view duration, its retention curve (who is still watching across the video) with where most viewers left (the time, and the scene there with its first line), and its click-through rate from its thumbnail when YouTube's API gives it for your channel. Read the numbers reads them now; they are read again once a day. An episode uploaded outside Studio can be linked to it (Link a video). The same numbers show on the production's own page.

The views come with the YouTube sign-in you have. The rest comes from YouTube Analytics, which needs one more permission, read only: Allow statistics signs the channel in again (the browser, or a code for a TVs client) asking Google for yt-analytics.readonly as well as the upload scope. Nothing on YouTube is changed by it.

A short plain summary of the numbers goes to the Director with the memory when it plans the next episode, and to Suggest ten: which episode held viewers best and least, where viewers left most ("at 1:12 of episode 3, in the scene "Kitchen talk" (40 s long)"), whether the shorter openings did better, and which thumbnails were clicked most. The page shows the same text (What the Director is told).

From the API: {"action": "series-get", "brandId": "KIT"} on POST /api/studio gives the series; series-build, series-memory, series-episode, series-idea-add, series-suggest, series-order, series-schedule, series-link and series-stats change it.

More from this video

A finished production can give far more than one video. Open it and choose More from this video → Make more from it: a checklist, each line with about how long it takes and what it costs before anything starts ({"action": "outputs-quote", "id": …} on POST /api/studio gives the same figures). Tick what you want and Make the ticked ones. Each output is listed under the production as it is made: play it, download its files, upload it, or Remove it.

• Vertical cuts (9:16) for YouTube Shorts, Instagram Reels and TikTok: one to three, each up to 15, 30, 45, 60 or 90 seconds. The Director reads the video's lines with their times and who says them, and picks the moments that stand alone: whole lines, from one to another, that make sense without the rest, grab attention in the first two seconds and end on a finished thought. It writes each one a hook (shown big at the top over the first seconds), a title and a description, in the video's language. Studio checks them: a moment longer than its length loses lines from its end until it fits, and one that overlaps another is left out. The frame follows whoever speaks: for each line, a vision model on your machines (any model the AI hub says can see pictures, such as gemma4:26b; set one with visionModel in Studio's settings, or "off") looks at the video's own frame halfway through the line and says where that person is (for the narrator's lines, the person the scene is about). The crop holds on each speaker and glides to the next over half a second; a small move isn't made, so the picture stays calm. Without a vision model, OpenCV's face finder follows the faces; where nobody is found, the crop stays in the middle. The captions are drawn in, larger than in the landscape video, a few words at a time with each word lit as it is said. Each cut has its own .srt, a cover picture and its YouTube text.
• Other languages: the same video in another language, as when you add one on a finished video: the Director translates it with the brand kit's names for each language, each person speaks with the kit's voice for them in that language, the timing and scenes are made again to the new lines' lengths, and the captions, title, description and thumbnail text are in that language. Only the new language is made; the others stay as they are. Its cost is the voice for its characters, the Director's calls and the render. In a film, the talking shots are lip-synced to the first language. They are made again in the new language only when you tick Lip-sync its talking shots again (shown with its time and price), because that needs the lip-sync model on the paid pod; otherwise the picture stays as it is, with the first language's mouths under the new voice.
• A square (1:1) or 4:5 cut of the whole video, for feeds: the frame follows the speaker as in the vertical cuts, and the captions are drawn in.
• Three thumbnails from the production's own pictures (the thumbnail's picture first, then scenes where someone speaks, spread over the video; frames of the video when it has too few), each with the title on it in another place and colour.
• Subtitles files: an .srt and a .vtt for each finished language.

The cuts, thumbnails and subtitles use only ffmpeg on this computer and the vision model: no video model and no GPU time beyond finding the person, and nothing is paid but the Director's one call that picks the moments. They need ffmpeg with libass to draw the captions and text (see Captions in the picture); without it, the cuts come without captions and the thumbnails without text, and the output says so. They are made one after another, beside anything else the production does.

Uploading an output is your click, as for the video: Upload to YouTube under it uses the choices in the YouTube box above (the channel, the playlist, private, unlisted or public, made for kids, altered or synthetic content). A vertical or square cut of three minutes or less goes up as a Short unless you choose As a regular video; its own title, description and captions go with it. An output remembers its links and its playlist, apart from the production's.

The files are in the production's folder under final/more/ID/. Removing a cut deletes them; removing a language deletes its translation, voices, renders and files (the first language can't be removed). Members can't make outputs yet.

Fixing one thing

Every step has Redo, Redo with another tool, and Edit and redo. Studio remembers what each step was made from, so a change only redoes what it affects. Change one voice line, and only that line's voice is made again and only its scene is rendered again. Each scene only sees its own time, so the scenes after it just move later.

Make it yourself. Every picture or clip scene, on the storyboard and on a finished production, has Make it yourself, to make it in Google AI Studio or the Gemini app on your own Google account (its use counts against that account, not Studio's key) and put it into the scene:

• The prompt Studio would send, ready to paste: for a picture, a line for each reference picture in the order to attach them (with Gemini images: the main picture first for a kit shot close, then each person's own picture, then the place's), then the description, the line on what the reference pictures are for, your notes and the frame; for a clip, what moves, its length and shape, from the scene's picture as its start frame.
• Download the reference pictures and the prompt (zip): the pictures numbered in that order, the clip's start frame, and prompt.txt (also GET /api/studio/refs?id=ID&scene=SCENE).
• Drop your picture or clip on the box, or choose it. A picture is the scene's picture; in a clip scene it is the clip's start frame and Studio makes the clip from it (when the clips are made). A clip (mp4 or mov) is the scene's clip, its first frame its poster. It counts as made: by hand, $0, and it stays until you Redo the scene (or a note to the Director asks for another picture). On a finished production its scene is drawn again and the video made again with it.

A picture of yours goes through the layout and continuity checks like any other, but a check never makes it again: when one finds a problem, the picture needs your eyes (Looks fine keeps it). For a kit shot close, a main picture of yours is checked as soon as it is in, and only once it passes do the scenes after it get it as their reference.

Change…

A made video, or one that stopped halfway, can be changed by saying what to change, in the Change… box on its page:

• make shot 4 closer, she should smile in the kitchen scene (a new picture),
• change the last line to "See you tomorrow" (a line's words),
• slower voice for the grandmother (how a speaker's lines are said),
• cut the second scene, swap scenes 2 and 3 (the edit).

Above the box, a strip shows the video's shots in order, one tile each with its length and its line; clicking a tile puts its name in the box ("shot 4 (The kitchen)"). Shots are numbered as the strip shows them.

The Director turns your words into a list of edits on named scenes and lines, and you see that list first: each edit with what it makes again (picture, clip, voice, scene, or only the edit), about what it costs and how long it takes, and how many steps stay as they are. Nothing is made until you press Make it (Make it for $X when it costs something); Don't change it drops it. When the Director can't tell which scene you mean, it asks, naming the ones it could be, and plans nothing.

What each edit makes again is decided by Studio, not the Director:

Everything else keeps its files as they are. A line or a picture that changed is checked again (the layout check looks only at the changed scenes); a cut or a move has nothing new to check. A scene drawn by an earlier version of Studio's renderer is drawn again whatever changes (free, on your machines), and the plan counts those too; for a video made before Studio noted the renderer's version, it says that every scene may be drawn again.

What it may spend. A change counts against the production's limit like the rest of it (see What a production may spend). A change whose cost would take the production past what it may spend without asking isn't made: Studio says so, and Allow $X more and make it raises the limit and makes it. A picture made on a paid machine is priced at that machine's hours, and the plan names the machine and its price an hour.

Back to the version before. Each change keeps the version before it: the storyboard, the steps, and every file the change could write over (the voices, the scene renders, the timeline, the finished video and its files) in versions/N in the production's folder, as copies that take no room on a disk that can clone files (APFS). Back to the version before puts the last one back, as it was: nothing is made again and nothing is paid. The last five versions are kept. Uploads to YouTube, what was spent and your notes to the Director stay as they are.

Change… is for videos Studio drew; a video cut from your own footage is changed on its cut list or with Tell the Director, and members' productions use Tell the Director too.

(POST /api/studio with {"action": "revise", "id": ID, "text": "…"}, then revise-confirm (with allow: dollars more, when it asked), revise-cancel and revise-undo.)

Another language, afterwards. A production made in English can be made in Turkish too once it has finished: Make it in another language under its files (or sparehand studio add-lang ID tr). The Director translates the storyboard from the first language and only the new language is voiced, rendered and packaged; the versions already made stay as they are. Up to 6 languages a production.

What the Director learns. When the layout or continuity check catches scenes and the Director's fix shows a general limit (how much text a bullets scene holds in a vertical video, say, or that a wide shot of a room names everyone in it), it writes that down as a one-sentence lesson, and every storyboard and cut list from then on is planned with Studio's lessons. A word the voice is misheard on more than once becomes a recommendation to add its pronunciation to the brand kit. Both are on the dashboard's Advisor tab (advisor.md), where you can add lessons of your own.

Benchmark

A change to a prompt, a model or the pipeline can make a series better in one way and worse in another, and by eye that shows only episodes later. The benchmark scores finished productions from the files they keep (their pictures, clips, voice lines and final video, and their record of steps and costs), so a new production is compared with the ones you judged right. Scoring makes nothing and changes nothing in a production.

sparehand studio bench score ID              # its measures, and how they compare with the golden set
sparehand studio bench golden add ID         # a production you judged right: the others are compared with it
sparehand studio bench golden list | remove ID
sparehand studio bench compare A B           # a table, and a contact sheet of their scenes side by side
sparehand studio bench list                  # every scored production, and what fell
sparehand studio bench run --kit KIT [--only NAME]   # the benchmark set (or one brief): says how long it takes; --yes starts it

Each measure is 0 to 100, higher is better:

Quality is the mean of them all but lip sync. Remakes (pictures made more than once), the minutes the production was busy and what it spent are shown with them, not scored.

The vision model is a local one through the AI hub, never a paid one: the hub's biggest model on your own machines that can look at pictures (gemma4:26b, say), or the one in SPAREHAND_BENCH_VISION_MODEL. A model the hub only passes on to a cloud provider is refused. Its answers are kept, so scoring again costs nothing until a picture changes. A production made before its series had a brand kit is scored against the kit of its project folder.

Golden productions are kept in the config folder (studio-bench.json), the scores in Studio's state folder. A measure more than 10 below the golden productions of the same kit fell: the score says FELL, and the Benchmark panel on the Studio tab marks it in red with the word. The panel shows each scored production's measures and the trend of the last ones against the golden line.

The benchmark set is a few short frozen briefs (lib/studio/bench/briefs.json), each with a seed, made Local only with the brand kit you give (--kit, else the golden productions'; without either it doesn't start), never on the kit's paid machine. Each is directed by the model on your own machines that can look at pictures (the one the scoring uses), and a storyboard with fewer pictures than its brief asks for goes back to it. A benchmark production isn't saved to the kit's folder and isn't among the brand's last videos the Director is shown, so it never steers a real episode. --only NAME makes one brief. The seed goes to ComfyUI, so the same brief makes the same pictures until a prompt or a model changes. bench run says how long it takes before anything starts, starts nothing without --yes, and doesn't start while another production is running. It makes the briefs one at a time (they share your graphics card) and stays in the terminal until the last has ended, then names the command that scores them (bench score).

How far to trust it. The measures from the files are exact. The vision model's are not: a local model sees who is in a picture and how wide the shot is well, but takes one grandmother for the other and names small differences that aren't there, so read cast as a rough sign across a whole production, never scene by scene. Look and palette compares with the kit's reference pictures, so a night-time episode scores lower than a daytime one. Before you act on a fall, look at the contact sheet (bench compare).

Tools

Studio picks the best tool that's available for your priority, and says why. A tool that isn't available says what it needs (an API key, a command).

Models a provider has retired. Providers retire models at a few weeks' notice, Google's previews every few months. Once a day (the first a minute after the dashboard starts), Studio asks Google's Gemini API and ElevenLabs, with the keys it has, for the models they serve now, and checks the model of each of their cloud tools against that list (Lyria, Gemini voices, images, video and text; the ElevenLabs voices and voice changer; ElevenLabs music and sound effects, and Higgsfield, have no such list). A tool whose model isn't there any more, while a model of the same family is (a newer version), is marked Model retired on its card, with that nearest model (the family's newest, a released one before a preview), and a notification says so once. A model with nothing like it in the list isn't marked (the list may not cover that kind of model); the log says so. Until its model changes it isn't chosen for a production, so one that would have failed half-way uses another tool from the start. Use … switches the tool to the suggested model; Keep it uses the model anyway and stops checking that tool (for a model the list leaves out that still works for you). A list that can't be read (no key, the provider down) changes nothing. To look now: {"action": "models-check"} on POST /api/studio. The marks are kept in ~/.local/state/sparehand/studio-models.json. Model names, endpoints and prices are in the registry, not in the code: change them in Studio → Settings → Tools, or in ~/.config/sparehand/studio.json. So is each picture and clip tool's rough time per picture (roughSeconds; hubSeconds on this computer; roughSecondsBy per model), which the storyboard's Where, and how long uses until Studio has measured three of its own on that maker.

Whisper's size: choose it from the list on Whisper's card, from tiny (fastest, roughest) to large-v3 (the best, slowest); small is the default. A bigger size hears more words right but takes longer, which matters for long footage. Each machine downloads a size the first time it uses it. On a Linux or Windows (WSL) worker with an NVIDIA card, sparehand studio install NAME also sets up the libraries Whisper needs to run on the card (about 2 GB), many times faster than on its processor and with far less of its memory; a worker set up before that needs sparehand studio install NAME once more. While a picture or clip is using the card, Whisper runs on the processor there.

Gemini (Google AI Studio)

The voices from Google AI Studio are Gemini's, called through the Gemini API with one key. Get it with AI Studio's Get API key, then enter it once under Studio → Settings (it's kept in the Keychain), or run:

sparehand studio key

GEMINI_API_KEY in the dashboard's environment works too.

Limits: a key on Gemini's free tier allows only a few speech requests a minute, and 10 a day, while a 90-second promo in two languages has about 35 lines. Studio spaces its requests to what the key allows, and makes the voices one language at a time, in the order of the production's languages: when the day's limit is used up, the languages voiced by then are whole and go on to their video, rather than every language half voiced. The production keeps what it made, waits, and carries on by itself when the limit resets; a notification tells you when. With billing switched on for the key (AI Studio → your key → Set up billing), the voice for such a promo costs a few cents. The same key makes pictures and video clips; clips need billing (the free tier makes none).

Make the voice yourself in AI Studio: while a production waits for the key's limit, you can make the missing lines in AI Studio's own speech playground instead, signed in with your Google account: what you do there counts against your account's limits there, not the API key's. The production's page lists every line still to make under Make the voice yourself in Google AI Studio, with the model, the voice, the style instructions and the text, each with Copy, as Studio would have sent them. For each line, choose Single-speaker audio, set the model and voice, paste the style instructions and the text, press Run, download the audio and press Give its file… on the line. Give several files… takes many at once, named as shown on each line (en-003.wav). A WAV is taken as it is; another kind of audio file needs ffmpeg.

Each file takes its line's place, and once every line is there the production carries on by itself with them. A line you made is listened to like any other, but never made again by Studio: if Whisper doesn't hear it right, it waits for your eyes (make it again and give the new file, or keep it). Changing the line's words, or Redo on it, makes it with Studio's voice again (your file stays as an earlier take). The list is there whenever lines are missing (a production that failed or was stopped too), and also lists the lines waiting for your eyes. A voice changer's lines (your footage said in another voice) can't be made this way.

Import from AI Studio: design a voice in AI Studio's speech playground (voice, audio profile, style, accent), press Get code, and paste the code under Studio → Settings → Import from Google AI Studio. It becomes Studio's voice for that language.

ElevenLabs

A second voice service, with natural voices in many languages. Make a key at elevenlabs.io (your profile → API keys) and enter it under Studio → Settings → ElevenLabs API key, or run sparehand studio key elevenlabs. Then choose ElevenLabs as the voice on a storyboard, or redo a line with it. Pick a voice from its library by setting its voice ID in Studio's voices.

Your machines

There's nothing to install on your other machines: Studio sets each one up by itself, from this computer, the first time it needs it. It installs Chromium, Whisper and ffmpeg for that machine's user only, in their own folders, with no administrator password. Until a machine is ready, its share of the work goes to the others, and this computer alone can make a whole video.

Studio → Settings → Your machines shows each machine's state, with Set up to start it yourself. Now and then a Linux or Windows (WSL) machine needs a few system libraries that only an administrator can add. Then that machine asks for its password there, once. The password is used for that install and isn't kept.

From the terminal, sparehand studio status shows what each machine has, and sparehand studio install NAME sets one up (hub is this computer).

Installing a tool

A tool this computer can install itself has an Install button on its card in Studio → Settings → Tools. Piper (free voices that run on this computer) installs with a voice for each language in Studio's voices, about 400 MB, and switches itself on. ffmpeg installs the same way when it's missing. Nothing needs an administrator password.

Local voices: Chatterbox

Chatterbox (Chatterbox Multilingual by Resemble AI, MIT) speaks 23 languages, Turkish and Arabic among them, on a spare machine with an NVIDIA GPU: free, and with no daily limit. Its Install button (or sparehand studio install myworker --with voices) sets it up in its own Python, about 5 GB with its model. Choose it as the voice in Settings, or as a production's voice tool on its storyboard.

It copies each character's voice from a sample: the first time a brand needs a character in a language, the sample is up to 15 seconds of that character's lines already made with Gemini in the production (with no request: switching a production waiting for Gemini's limit to Chatterbox keeps its voices), or else Gemini says about 15 seconds of their lines in their Gemini voice and style, and that sample is kept in the Studio folder's voices/BRAND/, so the next videos of the brand reuse it and the characters sound the same in every one (a new sample is made only when you change a character's voice). That is one Gemini request per character and language, ever. Then every line of a language is made in one job on the GPU machine: the model loads once (about half a minute), and a line takes about as long as it lasts. A line Chatterbox doesn't make is made with Gemini, and a line Whisper misheard is made again with another seed. Measured on an RTX 4060 laptop: five Turkish lines in 67 s, loading included. Close to Gemini in English, a step below in other languages: listen before choosing it. Without Gemini for a sample (no key, or its limit for the day), a character is said in Chatterbox's own voice, and the production says so.

Chatterbox misreads a name from another language (a Turkish name in an English or Arabic sentence came out letter by letter) and garbles very short lines. So: give the brand its characters' names in each language (below); a line of three words or fewer is said by Gemini when it has requests left today; and a line Whisper heard wrong is made again up to four times, each take a little calmer.

Names in each language

A brand kit can name its characters in each language (Studio → Settings → Brand kits → Names in each language, one per line: Maria = en Mary, es María). A translation is told to use exactly these names, and any name of the first language still left in a translated script (its lines and the words on screen) is changed to that language's name, so a changed line is voiced again. The voice then says each language's own name, in its own script, which every voice tool reads better.

Where Studio keeps its files

Productions (videos, voices, renders) and Studio's own tools on this computer (Piper and its voices, the private Python, Whisper's and Chromium's downloads) are kept in one folder. Choose it in Studio → Settings → Where Studio keeps its files, for example on an external drive. Studio moves what's there and keeps its new downloads there too. A production keeps only the renders it uses: older versions of its scenes are deleted when it finishes.

Private productions

Tick 🕶 Private (under Options) for a video that shouldn't be kept. A private production is erased by itself 10 minutes after you have downloaded its videos (each language's: time to download one again), or 24 hours after it last changed, whichever comes first; Erase on the production does it at once. Watching it in the dashboard doesn't count as a download. Erasing takes its record and folder on this computer, and its copies on your machines: sparehand clean removes them, and a machine that is off then (a stopped cloud worker) is cleaned the next time it is up. While it exists:

• Nothing of it goes into the brand kit: no new people, places or plates, no Keep as reference, and it isn't one of the brand's last videos the Director is shown. It isn't saved to the kit's folder either.
• Its pictures and clips made on your machines take their description from a file the job reads and deletes (kit/comfy.py --prompt-file), so it never shows in sparehand status or the job history, and ComfyUI forgets the job once it is made (--forget 1). A command tool of your own that would put the description on its command line isn't used.
• The Director keeps no record of its calls: Claude Code is run with --no-session-persistence. The other agents' programs (Codex, the Gemini CLI, Antigravity) keep every conversation, so they can't direct a private production; the Gemini API can.
• Notifications and the dashboard's log call it "a private production", without its title or words.
• Its voice samples stay in its own folder instead of the brand's.

Only the owner's productions can be private (a member's is billed, so it keeps its record), and not Solo pictures, which are made for the brand kit to keep. An art style the kit has no pictures of its people in yet is refused too, since making them keeps them in the kit: make them first, or choose the kit's own drawing. The cloud services a production uses (Gemini, ElevenLabs, Higgsfield…) keep what they are sent under their own rules; tick Local only as well to keep it all on your machines.

Adult productions

Tick 🔞 Adult (under Options; sparehand studio "…" --adult in the terminal) for a video whose pictures and clips may show the nudity of fictional adults. Cloud services refuse it under their own rules, and Studio doesn't try to get around them: an adult production is made on your own machines only, with a Director that runs there (a local model through Crew) and your own picture and clip models. What those models draw is up to them; Studio downloads no model for it.

Its limits are fixed, and checked by Studio itself, not only asked of the Director:

• The owner's own. A member can't start one.
• On your own machines only. Local only is on and can't be switched off, Make it all with Gemini is refused, no cloud tool or stock library is used (each tool says why), and a rented machine (a paid cloud worker) isn't used for it.
• From the description alone. No brand kit (not the default one, nor a website's), no project folder, no footage, no face or voice changed, no attached pictures or videos: only .txt or .md files. So nothing in it starts from a picture of a real person.
• Adults only, 25 or older. The Director is told that everyone is a fictional adult of 25 or older and gives their age; never a real or famous person; nobody forced, asleep or unaware; nudity only, no sexual acts. Words and ages that name or suggest anyone under 18 (girl, teen, schoolgirl, 16-year-old, Lena, 17, çocuk…) are refused in the description, its title, the attached text, the storyboard and every picture and clip prompt before it is made.
• Every picture looked at. A Director on your own machines that can see looks at each picture before it is used, and one where anyone looks younger than 25 (or it can't tell) isn't used: the next candidate is checked instead, and when none passes the scene says so. "Can see" means a Crew agent whose local model the AI hub says has vision (gemma4:26b has; qwen3:8b hasn't, and would answer without looking). That model also directs the video. Without one an adult production doesn't start, and the error names the local models that can't see. Its other candidates aren't offered. A clip starts from a checked picture and its prompt is checked, but the clip itself isn't looked at.
• Private by default. It is a private production unless you untick Private; it isn't saved to a brand kit's folder.
• Not uploaded. YouTube doesn't allow nudity, so Upload is refused: download it instead.

What Studio downloads, and its licences

Studio bundles none of these: each is downloaded from its publisher onto the machine being set up, only when you set it up or press its Install button, and is used under its own licence. They were checked on 20 October 2026 against each project's own repository, package page or model card; the same list is in the third-party notices that come with Sparehand. Licences can change, so check the ones you rely on, and check what your stock footage, music and voices from outside services allow under those services' own terms.

Programs:

Models for ComfyUI (from https://huggingface.co):

Piper voices (from https://huggingface.co/rhasspy/piper-voices; the repository is MIT, each voice has the licence of its recordings, given in its MODEL_CARD). Not all of them allow commercial use, and most were fine-tuned from the lessac voice, whose recordings are licensed for research only:

Before publishing a video made with a Piper voice, check that voice's line above: the English voice (lessac) and the Turkish and Hindi ones don't allow commercial use, and the voices fine-tuned from lessac may carry its research-only terms. Chatterbox's voices are MIT; Gemini's and ElevenLabs' come under those services' terms and your plan there.

Looks

Every video is drawn in one of five looks. Each has its own colours, fonts, background, card shapes and way of bringing things on screen:

Leave Look on The Director picks and the Director chooses the one that suits the subject and who will watch it; or choose one yourself. Within a look the Director also picks a tint (warm, cool, rose, violet, fresh, or the look's own): the glow of the background and the accent colour, chosen for the subject's mood, so two videos of one look don't share one background. A video with a brand kit keeps the kit's colours on top of the look; the kit can pin one look for every video (Look of every video in its settings), or leave it to the Director, who then picks among the looks that fit the kit's colours (the dark looks for a dark background, the light ones for a light one) and gives each video its own tint. The Director is also shown the last videos of the brand (their look, how they opened, the run of their scenes) and asked not to repeat them where the subject allows. You can change the look or the tint of a finished video from its page: only the scenes are drawn again (the voice and timing stay). The fonts come with Studio, so a video looks the same on every machine that renders it.

Languages and fonts

The looks' fonts cover Latin (Turkish, Vietnamese and the rest of Europe's letters) and Cyrillic. Arabic, Persian and Urdu come in Studio's own Arabic fonts: Cairo, rounded and friendly, in the dark, playful, clean and bold looks, and Noto Naskh Arabic, a book serif, in the warm and calm look. Naskh also draws what Cairo lacks there: Quranic marks (ﷺ, the end-of-ayah sign) and the letters of Pashto, Sindhi or Kurdish. They hold only Arabic letters, so in a line that mixes scripts the Latin stays in the look's font. A brand kit's font is used for Arabic when it has the letters (put an Arabic font first, say Tajawal, sans-serif, and have it installed on the machines that render); a font without them (Inter, Helvetica Neue, Arial, sans-serif) gets the look's Arabic font for that text, never whatever the machine happens to have, so Linux workers without Arabic fonts draw it the same.

A video in Arabic, Persian, Urdu or Hebrew is laid out right to left: text starts on the right, cards and lists run from the right, and the thumbnail's picture moves to the left. Terminals stay left to right.

The layout check reports a letter only when no font of the scene's stack draws it (the look's or the kit's fonts, then Studio's Arabic font). Scripts Studio has no font for (Hebrew, Ethiopic, Devanagari, Chinese…) are drawn with the rendering machine's own fonts when it has them, and are reported when the stack's fonts don't have them, so choose a brand kit font that covers the language.

The scenes can show about 55 icons, from everyday things (an apple, a tree, the sun, a heart, a book, a family, a mosque, a bird…) as well as machines. The Director uses one only when it shows the thing itself, and leaves the icon out when none does. For a moment none of the scene types suits (a picture built from shapes, a timeline, a map), the Director can design its own scene in the video's look.

Brand kits

A brand kit is what the Director keeps to for one product:

• the name, logo, colours and font
• the tone of voice
• pronunciations ("Sparehand" → "spare-hand")
• words never to use, words to keep untranslated
• what must never be claimed (pricing that isn't final, say)
• the project folder it belongs to, whose docs the Director checks claims against
• music: The Director picks (the usual), or Never: every video made with the kit has no music, only the voice, sound effects and natural sounds (see No music at all)
• its Audience on YouTube: not made for kids (the default), made for kids (every video of it is uploaded as made for kids) or ask at every upload (see Made for kids, and altered or synthetic content)
• an intro and an ending video, and a line shown over the intro (see Intro and ending)
• optionally, a folder to save finished videos to (see Save finished videos to)
• its art style: how its pictures and clips are drawn (see Art styles)
• how its scenes are shot: as the Director sees fit (the usual), or close and medium shots, moments of a main picture (see How scenes are shot), with an example video the Director is shown
• where its videos' pictures and clips are made on, and when the pictures are made (see Made on, and when the pictures are made)

Studio starts with none. Make one for each product you make videos for, under Studio → Settings → Brand kits:

• Make a brand kit from this folder: choose the product's project folder and the Director reads it (README, docs, icons, stylesheets) and drafts the kit: name, tone, logo, colours, pronunciations, words to keep. Check it and change what you like.
• Make a brand kit from this website: type the product's website (yourproduct.com). Studio itself reads it: the home page, up to four pages it links to about itself (about, pricing, features…), their stylesheets, the logo (an image that says it is the logo, else the apple-touch-icon, the page's share image or the favicon) and up to 8 pictures of the product. The logo and pictures are downloaded into Studio's own folder for the kit (~/.config/sparehand/studio-kits/), the colours and font come from the stylesheets, and the Director drafts the rest from the pages' text. Read it again on the kit reads the site anew: the logo, pictures, colours and tone are replaced, and your voices, places, intro and other settings stay.
• New, by hand: fill it in yourself.

A kit tied to a folder applies by itself when you choose that folder (or one inside it) for a video, and a kit read from a website applies by itself when what you ask for names that website ("a 30-second promo for yourproduct.com"). When you name a website that has no kit yet, and choose no folder and no kit, Studio reads the site for its kit first ("Reading yourproduct.com for its brand kit"), and the Director plans once it is drafted; the brand list on the form shows Read from yourproduct.com. Choosing No brand or another kit keeps your choice. One kit can be the default, for videos made without a folder or a website.

Only the engine reads the site, never an agent: it reads public http(s) websites only (not this computer or a private network), at most 1.5 MB a page and 15 seconds a call, and the Director is given the text it found as information, not instructions. Every call is logged with the production's network use. A local-only production, or Studio set to local only, reads no websites.

People's solo pictures

A picture with three or four people in it is where a small picture model goes wrong: one person's braids end up on another, someone appears twice, a pose is ignored. One person alone comes out right far more often, so a kit can have a solo picture of each of its people: the person alone, standing, the whole body, on a plain grey background. It becomes their reference picture (named <kit>-<person>-reference, like one kept with Keep as reference for…), and later pictures of them are made from it rather than from a group picture.

Under Studio → Settings → Brand kits, People's solo pictures and heights lists everyone of the kit's cast but the narrator, with ✓ where they have a solo picture. Make solo pictures… opens a production of its own, Solo pictures: (the kit):

• The Director looks at the kit's reference pictures and its picture rules, and for each person picks the one or two pictures that show them best and writes their look in a few plain words (in positive words only: the model draws whatever a prompt names, so "no hat" is sent back), naming what sets them apart from the others in those pictures, above all their hair. A group picture otherwise lends one person's features to another: made from the sisters' picture, the younger sister came out with her big sister's braid and bow. Someone none of the kit's pictures shows (a cousin, say) is made from their look alone: made from a picture of others, a cousin got the big sister's braid, bow and dress.
• Studio makes each picture tall (9:16), with the person named as the only one in it, on the picture makers as usual. Each has Redo, Redo with these notes and Make with…; Describe them again with notes asks the Director again for everyone.
• Keep as reference for… under a picture makes it that person's reference in the kit. No line is added to the kit's picture rules (the file's name says whose it is), and the line of a picture it replaces goes. Nothing is made into a video: there is no storyboard to approve.

The Director also gives each person a height: their standing height next to a grown man of the cast (1.0; a 5-year-old about 0.62, a 2-year-old about 0.48). It is kept in the kit and shown beside each person, where you can change it (0.25 to 1.3); a height you set stays when solo pictures are made again. Heights size people in a layered scene (below).

Layered scenes

A layered photo scene is put together from parts instead of drawn whole: the place empty (its plate), and each person alone, made from their solo picture in one pose and cut out of its grey background. Studio stands the people in the place where the scene says, so nobody is mixed up, doubled or missing, and the room is the same in every scene of it. The Director layers a scene when three or more of the kit's people stand in it, or its place was seen before (a rule of thumb it is told, not a rule Studio holds it to), and draws a close-up, a hug, or people sitting or lying whole, as before. Layered scenes are for people on their feet (standing, walking, kneeling): a person made alone sitting always comes with the chair and table they sit at, which the cut-out keeps and which never line up with the place's, and the place's table would have to be in front of them. So a scene where someone sits at a table, on a sofa or in bed, lies down or leans on furniture goes back to the Director to be drawn whole (with the kit's pictures as references, a short prompt and candidates). It needs ComfyUI pictures (on your machines or this computer) and the people's solo pictures: someone without one can't be in a layered scene, and the storyboard goes back to the Director when one is.

• In the storyboard a layered scene has people: for each person who (one of the kit's people), pose (one short sentence in positive words), at (left, middle-left, middle, middle-right, right), depth (front, or back: further into the room and smaller), facing (right, left or viewer) and stance (stand or kneel, for their height). Its generate says only the drawing style. light (morning, evening or night) is only for another time of day; left out, the place has its usual light. It has no ref or search; its animate moves only the place (see Motion below). Each person can also have enter and then (see Motion).
• The plate is one for each place, shape and look, shared by every scene there: made from the place's look and its reference picture when it has one, in the drawing style of the kit (its solo pictures' style, else the first layered scene there). A scene's own words never make another room. It is kept in the brand kit as the place's plate (brand/characters/<kit>-place-<place>-plate-wide.png), so every later video there has the same room, until the place's look, the kit's style or the tint changes, or you redo the place. Another time of day (light) is that plate with its light changed, made from it; a vertical video's plate is made from the wide one, so the tall room is the same room.
• Each person is made alone, tall, from their solo picture, named as the only one in it, and BiRefNet (MIT, in ComfyUI itself, 444 MB, fetched with the pictures models or the first time it is needed: sparehand studio status shows matte) cuts the grey away. The same person in the same pose (the same pose words) is one picture in every scene; a mirror image turns them the other way.
• Candidates: where pictures are made as candidates, plates and people are too, and the picker chooses the best: for a person, the one that is them, alone, in the pose asked for. A plate or a person is used in many scenes, so this pays off more than for a single picture.
• Sizes: each person is scaled by their own body in the cut-out (nothing else is in it): a grown man standing in front is 0.82 of the frame's height (0.6 in a vertical video; at 0.9 his head left the frame when the picture zoomed in), everyone else by their height in the kit, a kneeling person 0.74 of that, four fifths at the back. Each gets a soft shadow under the feet.
• Redo: the storyboard shows the scene put together, and under it a chip for the place and for each person, each with Redo and notes of its own. Redoing a person makes only their picture again, and every scene with them gets it. Redo on the scene itself puts it together again from its place and people; with notes, the notes are for the place, which is made again for every scene there (a scene never gets a room of its own). The layout check can move people (their at, depth and facing) without making any picture; the continuity check names the one person whose picture is wrong (or the place), and only that is made again, or gives them a new pose.

Measured on the 8 GB laptop card: a plate 12 to 18 seconds, a person with the cut-out 14 seconds (the cut-out alone about 2); with 3 candidates each, three times that.

Motion

People in a layered scene move like cut-outs in a stage play, drawn by the renderer: free, the same on every machine, and nothing about a person drifts, because they stay the same pictures.

• Always: each person breathes a little and sways, out of step with the others, and bobs gently while their own lines are spoken (the line's speaker is the person with the same id).
• On a word: then is a list of steps, each with at, a cue like a label's ("2:amin": when the scene's second line says "amin"), and one or more of: pose (a new pose: one more picture of them, made and cut out like the first, cross-faded in over 0.3 s), facing (they turn: the same picture mirrored, flattening and opening the other way; viewer is a picture of its own), to (they walk to another spot: "middle", or { "at": "left", "depth": "back" }, with a small bounce a step and growing or shrinking with the depth), leave (left or right: they walk out). enter: "left" on a person walks them in as the scene starts; a first step { "at": …, "enter": "right" } walks them in on that word. At most 4 steps a person and 4 new poses a scene.
• Turning to the speaker: someone the Director doesn't turn (no facing anywhere) starts facing the middle, turns toward whoever speaks, and faces the nearest of the others while speaking.
• Staging: the Director is told to spread people through the room (one or two at the back), turn them toward each other, and move one or two of them in every scene. A scene where everyone stands at the front, facing the viewer, with nothing moving, goes back to it (that was the stiff, pasted look of the first layered episodes).
• The camera keeps the scene's move (a slow zoom in by default, out, a pan), a little gentler than for a whole picture so heads and feet stay in the frame, and drifts slowly toward whoever is speaking, bringing them toward the middle.
• The place moves with a clip: animate on a layered scene describes only the place ("rain running down the window glass, the curtains swaying"). Wan (or Veo) animates the empty plate, and the people stand in front of it. One clip of a place, light and animate is shared by every scene with the same ones and counts once against the clips a production may have. It plays from the start, then loops with a short cross-fade, however long the scene is. Without a clip machine (or with clips switched off) the scene keeps its still plate. Redo on one of those scenes makes the clip again for all of them.
• Translations: a step's cue word is the translated line's word, as for labels.
• On the storyboard each person's chip shows every picture of them (each pose), and Redo makes all of them again.

node kit/studio-kit.mjs stills TIMELINE OUTDIR T… draws the frames at those seconds and writes where each person is in them (stills.json), for checking motion without a whole render.

How scenes are shot

How scenes are shot under the kit chooses between letting the Director shoot each video as it sees fit (wide rooms, layered scenes, whatever the story needs) and close and medium shots, moments of a main picture: the way the first episode of a family series was shot, which looked right where later ones, with wide rooms of small cut-out people and flat light, didn't. With it:

• Close and medium shots. The Director is asked for the people large in the frame, their faces close enough to read, warm light, and one main place for the story.
• A main picture. The first photo scene in a place shows everyone there, in the kit's words; most later scenes there are small variations of it (another expression, a hand, a lean) and take it as their ref, together with the kit's pictures of each person. A main picture is a still (a main picture that is also a clip goes back to the Director); a clip is one of its moments.
• The main picture is checked before anything is made from it. As soon as it is made, the Director (or another writer that can see pictures) looks at it alone against the kit's pictures, people, rules and places: the continuity check, on one picture. Only once it passes do the scenes after it get it as a reference, so a fault in it (a face in the window, an extra child) can't spread to every picture made from it. When the check finds a fault, the main picture is made again first (its new prompt keeps everyone's looks, and it replaces the one it had only when it is better), when it is made free on your machines, or on a paid machine of yours within the checks' allowance for remakes; made with a paid tool it isn't made again by itself, but waits for Remake for $X. With ComfyUI pictures, a moment of a main picture that didn't pass is made with the place's own empty picture behind its people instead (the kit's plate of the place, else one made once from the place's look and kept in the kit, as for layered scenes), with each person from their own picture: those scenes keep one room, the same in every later episode there, instead of each drawing its own from words. The room's picture is a wide shot, so these pictures come out wider than a moment of a main picture would. The checks get that picture of the room too. When it still doesn't pass, or a new picture can't fix it, or it is your own picture, or it waits for you, it needs your eyes and the scenes after it are made from the kit's pictures only. Accept on it counts as checked. The verdict is kept for that picture, so it is checked once. With Gemini images the main picture goes first, labelled as the shot the new picture is a moment of, then each person's own picture, then the place's.
• Rich prompts whatever the picture tool (60 to 150 words, each person by the kit's name with their look), not the short ones a small local model needs.
• No layered scenes: every picture is drawn whole, and a storyboard with one goes back.
• Fewer clips: 3, at most 4 (or Settings' limit when it is lower), for small character moments.

Example video gives the Director one of the kit's productions as an example of what is wanted: each of its scenes, what its picture was made from and its first line.

A LoRA for the kit's people

A LoRA is a small file (about 90 MB) trained on a brand kit's people and drawing for one local picture model. With it, that model draws the kit's people from their names and looks in the prompt, without being shown their pictures. A kit keeps one per model in its settings:

"loras": { "flux2-klein-4b": { "file": "brand/lora/my-brand-flux2-klein-4b.safetensors", "strength": 1, "word": "mbstyle" } }

file is kept with the kit's pictures (in its project folder or repository) and goes with each picture's job; strength is from more than 0 to 1.5 (1 unless said); word is the word it was trained with, put first in the prompt. Every picture of the kit made with that model on your machines gets it (kit/comfy.py image --lora FILE:STRENGTH), and then the people's own pictures stay out: the place's picture, a main picture and pictures of your own still go. Not in a video with an art style of its own (the LoRA draws the kit's look), not for a solo picture, and not for Gemini's pictures.

Measured (2026-10-28). A LoRA for FLUX.2 [klein] 4B, trained on a kit of four people: their 8 solo pictures, 3 group pictures, 3 frames of an earlier episode and 3 test pictures (17 in all, each with a caption naming who is in it and how they look), rank 32, 1500 steps: 41 minutes on a rented A40 with ai-toolkit (MIT; it runs on the pod and is gone with it), about $0.40. On a test video's seven scenes, two seeds each, with the same prompts: with the LoRA and the room's picture, everyone looked right in all 14 pictures (Maria's golden-brown curls, Leo's braids and bows) and nobody was drawn twice, at about 6 seconds a picture on the A40; without the LoRA, the 4B needs the four people's pictures for that (about 14 seconds a picture) and drew one person twice in 14; with neither, Maria came out blonde. The LoRA together with the people's pictures drew Maria twice, which is why they stay out.

Films

A film is a video told in shots, like anime or a movie: action that carries on from one shot to the next, people who say their lines on screen, cuts that land on movement. Choose the Film (connected shots) recipe, or set How scenes are shot under the kit to A film (then every video of the kit that makes a picture is one). The Director writes a shot list instead of narrated scenes:

• Every scene is one shot, 2 to 6 seconds, a picture set moving (a photo scene with generate and animate), with at most one line. Its props: shot (wide, medium, close, over-shoulder, insert), who (everyone seen in it), generate (its first frame), animate (what happens), camera, start, end (optional: the frame it lands on), seconds, cut (cut, match or continue: how it joins the next one) and group (the scene it belongs to, for reading and for the chapters).
• Where a shot starts: key, a first frame drawn for it (a new angle after a cut); continue, the last frame of the shot before (the same take goes on, no visible cut); after:<id>, the last frame of that earlier shot (back to the wide shot after two close-ups).
• Talking shots: a line whose speaker is in the shot is said by them on screen, in a close or medium shot that starts from a key frame of them, at most 12 words.
• The storyboard shows the shots under the scene each belongs to, with what each one is (its kind, who is in it, where it starts, its length, lip-synced or not, the cut after it).
• Checked before you see it: a shot over 6 seconds, a talking shot that doesn't start from a key frame of its speaker, a shot that continues a talking close-up (its last frame is the wrong angle for the next one), someone named in a shot who isn't in its who (a clip model brings in a stranger for them), a group or a new place that doesn't open on a key frame, more than 3 continuing shots in a row, more than 16 shots a minute, and shots that add up to far more or less than the length asked for. Anything wrong goes back to the Director.

Key frames first. While you read the storyboard, only the key frames are made: the first frame of each shot that starts from one (and the end frame of a shot that lands on one), the way a photo scene's picture is made (the kit's pictures of who is in it and of the place, or the kit's LoRA for the model, candidates and the picker, the start-picture check). You approve the film as a strip of stills; the shots, the GPU minutes, are made once you approve it (or when you press Make the clips now). A film's key frames are made as candidates on a paid machine too (about 24 seconds each on a 40 GB card, in the estimate you approve).

Connected shots. Approved, the shots are made in story order, each a clip of its own length (2 to 6 seconds, to the half second on your machines):

• a shot from a key frame is that picture set moving (Wan 2.2 I2V); one with an end frame moves from its first frame to it (Wan's first-last frame mode, the same model files);
• a shot that starts from another (continue, after:<id>) waits for that shot, takes its last frame (each shot keeps it, <shot>-last-….png in the production's assets), checks it like any start picture (who is in it, their looks) and goes on from it, on the same machine. When that shot has no last frame (it couldn't be made) or its last frame doesn't show who this shot has, a new key frame is drawn for it from its generate, with the kit's pictures, and the chain breaks there (a visible cut);
• a shot is made again when the shot it starts from is, or its own first or end frame, length or camera changes.

Lip sync. A talking shot is made once its line is voiced: InfiniteTalk (MeiGen, Apache-2.0, native in ComfyUI) moves the speaker's mouth with the line's voice (in the first language, with 0.3 seconds of silence before and after it, so the mouth starts and stops with the voice) and keeps its key frame as frame 0, so it cuts cleanly against the shots around it. It runs on a machine set up --with lipsync (a graphics card of 40 GB or more: sparehand studio install NAME --with lipsync, about 17 GB of models; when the disk or the volume hasn't the room, the install says how much more it needs). A line longer than 3.2 seconds is made in parts, each from the last frame of the one before. The other languages' voices go over the same shots. Each is a step of its own (talk:<shot>, Redo makes it again); a talking shot that can't be made shows its key frame while the line is said.

The edit. The shots play back to back, each once at its own length (a talking shot as long as its line and the silence around it), with a hard cut between them and a light fade only where the scene (the group) changes. A spoken line sits where it was lip-synced, a narrator's line a moment into its shot; a line longer than its shot holds the shot's last frame. Sound effects play at their cues inside a shot, and music runs under it all where the kit allows music. The chapters are the scenes, each named by the title of its first shot. With Clips in 1080p on (Settings), every shot, a talking one too, is made larger on the machine that made it, as any clip is; otherwise the render scales it up from its own size (832×480 for lip sync, the clip model's for the others). A shot can be made by any clip tool that starts from a picture (a cloud one too); only ComfyUI's Wan 2.2 14B lands on an end frame.

The estimate gives the shots a line of their own: how many (talking, key frames to draw), the seconds of film, where they are made, about how long from here on and what it costs there, and the machine minutes (and dollars, on a paid machine) a minute of film takes. The production's checklist has a Shots stage for the shots and their lip sync. Measured on a 46 GB A40 (Runpod, $0.59 an hour), with the 14B in Q8 at 1280×704 (each clip loads its model in a fresh ComfyUI, about a minute and a half): a key frame about 24 seconds, a 3-second shot about 5 minutes, a 4-second one about 7, a 5-second one 8 to 9 (with an end frame or from another shot's last frame), a 2.4- to 3.8-second talking shot about 4 (InfiniteTalk at 832×480). A 35-second film of 9 shots, 4 of them talking, took about 55 minutes there.

Art styles

Art style says how a video's pictures and clips are drawn: the kit's own drawing (the usual), Anime (clean line art, cel shading, big expressive eyes), 3D animated (soft global illumination, rounded features), Watercolour storybook, Clay / stop-motion, or your own words (up to 200 characters). A brand kit has a default under Settings → Brand kits, and the new-production form can choose another for one video under Options (The brand kit's keeps the kit's default; The kit's own drawing goes back to it). The prompts describe the style in plain words (no studio or film names, which can be refused); the Director writes every picture and clip in it, whatever the kit's picture rules say about how things are drawn (their people, looks and places stay), and each picture's prompt says it once more.

Each style has its own reference pictures. The kit's people and places are drawn in the kit's own style, and made from those pictures every picture would be pulled back to it. So a video in another style is made from pictures of the people (and places) in that style, kept beside the kit's own as <kit>-<who>-reference-<style>.png (and <kit>-place-<id>-reference-<style>.png):

• The first time a video uses a style the kit has no pictures in, Studio redraws them: a production of its own, Solo pictures: (the kit) (the style), made with Gemini images from each person's own solo picture ("the very same person, now drawn in this art style") and each place's picture. When the kit's folder has pictures in that style already, in brand/<style>/ (for 3D animated, brand/3d/; a sheet first, two at most), they go along to show the style: a kit's brand/3d/sheet-16x9.png is the starting point for its 3D set.
• Keep each one you like there (Keep as reference for…; a place's picture keeps its place), or redo it. Meanwhile the video's pictures of those people wait ("Waiting for the 3D animated pictures of Maria and Leo"), and they are made as soon as they are kept.
• Pictures in other art styles under the kit lists each style's people and places (✓: kept), with Redraw them in… for the ones still missing.

The episode-1 rules (close shots, the main picture and its check) and the check that a remake keeps everyone's looks apply in any style.

Intro and ending

A series looks like a series when every episode opens and closes the same way. Give the kit an Intro video (a few seconds: the show's logo coming alive, its name said) and an Ending video (the characters waving goodbye), either or both: a video file on this computer (its full path) or one you attach (up to 30 MB; give a bigger one by its path, up to 200 MB). Studio keeps its own copy in ~/.config/sparehand/studio-kits/, so the kit doesn't depend on where the file was. Remove takes one off again.

Every video made with the kit then opens with the intro and closes with the ending, in every language, and they take the place of the Director's own title card and end card: the Director is told about them, so it plans no greeting or title scene at the start and no goodbye, "see you next time" or logo end card at the end (a storyboard with a logo end card is sent back to it). It ends on the last moment of the subject.

• The episode title over the intro: the Director can give a short episode title (introTitle, up to 30 characters, translated with the rest), drawn over the last second and a half of the intro. Over the intro in the kit sets the line per language, one per line: tr = {title} ({title} is the Director's episode title; a fixed line like en = Season 2 works too). Without a line for a language it is the episode title alone; without an episode title, nothing. It needs an ffmpeg that can draw text (libass, as for captions in the picture); without one the intro plays as it is and the production says so.
• The frame, frame rate and sound are the video's: a clip of another shape is scaled to fill the frame when it is close (a 4:3 clip in 16:9), else fitted whole with bars (a vertical clip in a landscape video); it plays at the video's 30 frames a second, its sound at the same loudness (a clip without sound is silent). So one pair of clips works for both landscape and vertical videos, though one made in each shape looks best.
• Captions and chapters: the captions start after the intro (the .srt is shifted by its length, and captions drawn into the picture are drawn over the video between them), and the chapters start with 0:00 Intro (Giriş in Turkish), each scene's chapter moved later by the intro's length. YouTube wants every chapter at least 10 seconds long, so after a shorter intro the first scene's chapter joins it.
• The thumbnail is drawn from the scenes as always, never a frame of the intro.
• For one video without them: untick Use the kit's intro and ending on the form (it shows when the chosen kit has them), or sparehand studio "…" --no-intro.

They go around videos made from scratch and around your own footage when it has a kit; highlight clips (several short videos at once) don't get them. The step is Intro and ending on the production's page: it runs after the video (and its captions) are made, so changing the kit's clips and pressing Redo on it makes only that again.

Save finished videos to

Studio keeps every production in its own folder (Settings → where Studio keeps its files). To have the finished files land with the rest of a series as well, give the kit a folder under Save finished videos to: a full path to a folder that exists on this computer, like /Users/you/Movies/my-show/episodes. It is off when empty.

A video with pictures a check sent back that still need your eyes is made, so you can look at it, but it isn't copied there yet: keep those pictures (Looks fine) or remake them, and it is copied then. Save to a folder… on the production copies it as it is. Redo on such a picture, without notes, makes it from what the check found (the check's own new prompt when it wrote one), not from the same prompt again.

When a video made with the kit finishes a language, Studio copies that language's **video, thumbnail, captions (.srt) and YouTube text (.txt)** into a folder of its own there, not the voice or the working files:

episodes/
  02-bedtime-story/
    02-bedtime-story-tr.mp4
    02-bedtime-story-thumbnail-tr.png
    02-bedtime-story-tr.srt
    02-bedtime-story-youtube-tr.txt

• The number is the next free one in that folder (after 01-…, 02), chosen once for the production and remembered: every language of it, and every time it is made again, goes into the same folder.
• The name comes from the video's title in plain letters (Turkish ç, ğ, ı, ö, ş, ü become c, g, i, o, s, u), at most about 30 characters.
• Made again: after an edit or a redo, that language's files are replaced. Files you put in the folder yourself (a prompt.md, notes) are never touched, and deleting the production in Studio leaves the copies where they are.
• On the production's page, the files section says Saved to …, with Show in Finder. sparehand studio show ID prints it too.
• For one video without it: sparehand studio "…" --no-export (the API's noExport: true).
• Another folder for one video: on the production's page, Save to a folder… (or Save to another folder…) in the files section. With the page open on the Mac that runs Sparehand, the Mac's own folder panel opens; from another device you type the folder's full path on that Mac. The finished files are copied there at once, into the next numbered folder, and every later version goes there instead of the brand kit's folder. It also works for a video made without a brand kit or with --no-export. Stop saving here forgets the folder: the copies in it stay, and the next version goes to the kit's folder again, into the numbered folder it had there. The same rules apply as for a kit's folder (below). A private production has no such choice: its files are downloaded. From the terminal: sparehand studio save ID FOLDER (--in-repo for a folder inside a git repository) and sparehand studio save ID --stop. The API: {"action":"export-to","id":"ID","to":"/full/path"} ("inRepo": true for a folder inside a git repository, "to": null stops).

The folder can't be inside Studio's own folder. A folder inside a git repository (a code project) is refused unless you confirm it, so a repository doesn't fill up with videos. If the folder isn't there when a video finishes (a drive that isn't connected), the production says it wasn't saved, and the files are still in Studio's folder.

Voices are Studio's, not a brand's: the usual voice for each language (tool, voice, audio profile, style, accent) is set once under Studio → Settings → Voices. The Director chooses the voice for each video (on by default, in Settings): the Director picks the voices that suit each storyboard (a calm storyteller for a gentle story, a bright quick one for a playful promo) from the voice tool's own, and you see its choice under the storyboard's tools. With Gemini TTS it picks a voice, a style and an audio profile. With ElevenLabs it picks from the voices in your ElevenLabs account (what each one is says its accent, age and use), with macOS or Piper from the voices installed for each language; those take no direction, so the voice itself is how it sounds, and a macOS or Piper voice speaks one language, so it picks one for each language of the video. When several people speak (a story with characters, a dialogue, an interview), it casts a voice for each of them and marks every line with its speaker, so the voice changes line by line; each line on the storyboard shows who says it. The usual voice fills in whatever it leaves out, and each language keeps its own accent from Settings. Switch it off to use the same voice in every video. The Accent field offers the usual accents of each language to pick from (British, Australian or Indian English; Egyptian, Levantine or Gulf Arabic; Istanbul Turkish; Mexican or Castilian Spanish…), or type your own. Gemini voices follow it; with ElevenLabs, Piper or macOS, the accent is the chosen voice's own, so pick a voice that has it. A production can change it for itself, under Change it for this production on its storyboard.

One person's voice. When several people speak, each of them has Change NAME's voice under the storyboard's voice: the voice, its style and its audio profile (who is speaking, how old, how they sound: Gemini voices follow it, so "a young mother in her late twenties with a light, clear voice" makes the same voice younger). Listen plays a few seconds of what is typed, saying one of that person's lines, before anything changes (a Gemini voice line: a fraction of a cent). Save, and say NAME's lines again keeps it for this production and makes only that person's lines again; tick also for the brand kit to keep it for the videos after this one. Back to the cast's voice undoes it. In a brand kit (Studio → Settings → Brand kits → People's voices) Listen to plays a person's voice as their line in the box says it now, or another voice you type beside it with their style and profile, in the language you pick.

Local only

With Local only, no step may use a cloud service:

• the Director is a local model through the AI hub (add one to Crew; see AI models)
• the voice is macOS's or Piper's
• pictures and clips made with AI are ComfyUI's, on your machines (Pictures and clips on your own machines)
• Whisper and rendering run on your machines

Every network call a tool makes is logged with the production, and any call that would leave this computer is refused. The production shows "N calls, none outside this computer".

For members

People you add as members on the People tab (credits.md) get the Studio tab too, when Studio is on, and make their own videos on their prepaid credits. What they see and get:

• Their own productions only. Every production records who started it. A member sees, opens, edits, resumes, stops and downloads only theirs; you see all of them, each with the person's name.
• No settings. Members have the recipes, the tools and the looks, and attach their files (a logo, screenshots, short videos for the footage recipes). They can't use folders or files on the hub computer, brand kits, Studio's settings, API keys, your machines' setup or YouTube: they download the finished files.
• You approve each request (the usual way). A member sends a brief; you get a notification and a Needs you entry with their name, the brief, about what it would cost you and a suggested price. Nothing is planned until you open the request and press Approve: there you choose its Director, your own Master (your Claude, no token cost: its tokens are yours, covered by the directing fee) or any writer billed per use (the Gemini writer, a Crew agent of the Claude API or Kimi kind with its own key), each with its estimated Director cost for that brief, and its price: the suggested one, or a number of your own, which is then the whole charge whatever it uses. Then it runs like your own production; the member pays the price (held at the storyboard, charged when the run settles), approves the storyboard so the content stays theirs (tick I approve their storyboards too to do that yourself), and gets the finished files. Decline returns it with a note and charges nothing. Your approval of each request is what keeps this your own use of your subscription: a member can't start, resume or plan one on your Director, and nothing runs on it by itself.
• The suggested price, and what a member pays by default: your costs (the voice, the pictures and clips, the Director's tokens when billed per use) times the markup, the machine minutes at prices.jobs.perMinute, plus a flat directing fee in credits that you set (20 by default), rounded up to whole credits. The member's form shows the range this gives for their video. What the production really uses is charged when it ends, up to 1.5× the estimate, unless you set a price.
• Billed per use, no queue. Settings → Members' productions → Billed per use, no queue: a member's storyboard is planned at once by the Gemini writer when Studio has a Gemini key (Settings), else by a Crew agent of the Claude API or Kimi kind with an API key of its own, and charged per token; there is no directing fee. Your Claude or ChatGPT subscription is never used for a member's production this way (their terms don't allow reselling it), and a member whose production can't get such a Director is told so. The Settings line says when there is none yet.
• A Crew agent directs a member's production only when members' agents are on ("membersAgents": true in app.json, off by default; the People tab says which). The Gemini writer only writes text through its API; a Crew agent works as your own user on the hub and reads files there, so until you turn members' agents on it is never a member's Director, however it is billed, and such a member's production is written by the Gemini writer or not at all. Once you have approved a request yourself and chosen a Director for it, that is your choice and the switch doesn't apply. See crew.md.
• Cost, price and margin, for you only. Every member's production carries a cost line: the estimated cost to you (the tools at their prices, the chosen Director's tokens, the machine minutes at prices.jobs.costPerMinute when you set it, else shown as minutes), the suggested price and the price the member pays; after the run, the actual cost (from what every step recorded), the charge and the margin. Above the productions, Members this month sums them up per member and in all, and the People tab's balance row shows the same three figures. Members see none of this.
• The price in credits, before anything is made. The storyboard shows what making it will take: the voice, the Director's remaining calls, clips made with AI, and the minutes on your machines. Approving it holds that amount; each step then counts what it really used (the characters spoken, the pictures and tracks made, the seconds of clips, the Director's tokens, the machine minutes), and when the run ends the hold is settled: the rest is given back, or an overrun charged, up to 1.5× the estimate. Planning the storyboard is a small run of its own.
• A clean stop. A step that the hold and the balance can't cover isn't started: the production stops, says why, and keeps everything made so far. Resume carries on with a new hold once the owner has added credits. A storyboard whose price is above the balance can't be approved; starting anything needs a balance above zero.

What a member pays is your own cost times the markup in app.json ("markup": 1.3 by default: 30% over), from the tools' prices in the registry (voices per 1,000 characters, pictures, music, clips per second) and the Director's tokens at the provider's list price, plus machine time at prices.jobs.perMinute (credits a minute, by machine name, "hub" for this computer, default for the rest; nothing when unset). Owners are never charged. The markup itself and your cost lines are yours alone: a member's view of a production carries its price in credits, never the rate over your cost. See Credits.

The members' settings are kept in studio.json; app.json can give their defaults, for a hub set up by hand:

"studio": { "memberDirector": "owner-approves", "directingFee": 20, "ownerApprovesStoryboard": false }

memberDirector is owner-approves (the default: you approve each request) or per-use (no queue); directingFee is in credits; "studio": false still switches Studio off.

From the terminal

sparehand studio "90-second promo for Sparehand" --recipe promo --lang en,tr --brand
sparehand studio "A tour of this project for new contributors" --recipe explainer --folder ~/code/project
sparehand studio "Sourdough in 30 seconds" --recipe teaser --format 9:16
sparehand studio show ID          # the storyboard, the tools and why, then the files
sparehand studio approve ID
sparehand studio wait ID          # returns when it's done
sparehand studio edit ID en 4 "A better line."
sparehand studio redo ID voice:tr:7 --tool gemini-tts-lite
sparehand studio add-lang ID de   # the same video in German too, also once it has finished
sparehand studio files ID         # where the finished files are
sparehand studio save ID ~/Movies/episodes   # copy the finished files to a folder of your choice (save ID --stop: no longer)
sparehand studio key [gemini|elevenlabs|pixabay|pexels|freesound]   # an API key, kept in the Keychain
sparehand studio "Our trip, one minute" --recipe montage --footage ~/Movies/trip --format 9:16 --music ~/Music/song.mp3
sparehand studio "Dub it into Spanish" --recipe dub --lang es --footage ~/Movies/talk.mp4 --consent
sparehand studio "Five clips of the best moments" --recipe shorts --footage ~/Movies/podcast.mp4
sparehand studio "The main points, five minutes" --recipe summary --footage ~/Movies/lecture.mp4 --seconds 300
sparehand studio youtube connect  # once: your channel, with a code entered at google.com/device
sparehand studio upload ID --privacy unlisted
sparehand studio upload ID --video   # a vertical video as a regular one (fitted into 16:9), not a Short
sparehand studio bench score ID      # its quality measures, from its saved files (see Benchmark)

--approve starts it without waiting for you to approve the storyboard; --local makes it local only. --folder DIR makes it from that folder, on any subject; --brand makes it about the brand kit's product (the default without a folder), --no-brand about anything. --format 9:16 (or --vertical) makes it vertical. --footage FILE|DIR gives your own videos to a footage recipe; --no-music makes a video with no music at all (any recipe that has music); --no-intro makes it without the brand kit's intro and ending, --no-export without copying it to the kit's folder for finished videos. --music, --face PHOTO, --source-lang (the footage's language, when Whisper might guess it wrong), --consent and --format 1:1 go with it. --burn-captions draws the captions into the video (--no-burn-captions doesn't), --reframe smart|center|bars says what happens to wide footage in a vertical video, and --broll none|some|lots how much B-roll the cuts get.

Recipes

A recipe tells the Director what kind of production it's making: the brief, the default languages and length, the shape of the scenes and which steps run. Pick one on the form, or with --recipe.

The recipes for your own footage are in Your own footage.

For What's new, Team update, Narrated article and Text read aloud, attach the release notes, your notes or the article (or paste them in the description): the Director works from them.

A recipe is a file in lib/studio/recipes/, and a new one needs no code. Its fields:

• id, label, blurb: the file's name, and what the form shows
• director: the brief the Director follows; rules: extra rules for it, one per line
• defaults: the languages, the length in seconds and the format ("formats": ["9:16"] starts it vertical)
• steps: which steps run. Without layout, render and encode there is no video, only the voice, the timings and the captions
• scene: how many lines a scene has and how long it lasts ({ "lines": [1, 3], "seconds": [3, 9] } when it isn't set)
• endCard: the seconds the last scene stays after its last line; logoEnd: false doesn't end on the logo
• order: where it is in the list
• film: true: the storyboard is a shot list (see Films)
• for your own footage: footage: true, and lines (captions: the words said; voice: a new voice; none), anchored (each line at the moment of the original sentence), audio (the footage's own sound by default: keep, duck, mute or background), music, fitLength, convert (a voice changer), consent, face, autoPlan (the footage whole, with no Director), titles: false (no title cards), parts (several clips, each its own video: highlight clips), burnCaptions (captions drawn in by default)

Where things are

• ~/.config/sparehand/studio.json: settings, the brand kits and their promotion plans, changes to the tools (no secrets)
• ~/.config/sparehand/studio-series/KIT.json: a brand kit's series: its memory, ideas, schedule and the numbers last read
• ~/.local/state/sparehand/studio/productions/ID.json: a production's storyboard, steps, events, costs and network log
• ~/.local/state/sparehand/studio/productions/ID/studio-ID/final/: the finished files
• …/studio-ID/out/cuts/: the cuts of your footage (kept until they change)
• …/studio-ID/final/more/ID/: More from this video's outputs (the cuts, thumbnails and subtitles)

Not yet

These come later:

• the square 1:1 format for videos made from scratch (your own footage has it)
• pictures from stock libraries other than Pixabay and Pexels
• tutorials recorded from the real dashboard
• other platforms than YouTube