rendemo_add_interlude
ChatGPTInsert a full-frame chapter SLIDE — a slideshow-style interrupt that titles the next part ('Connect your data', 'Invite the team'). atSection is the chapter index (0-based, in the order the film's establishing/wide shots open each chapter); the slide renders just before that chapter. NOTE: by default chapters are already marked by animated on-screen titles over the footage (the produced-film look) with no slides — use this only when you deliberately want the full-frame slideshow treatment instead.
rendemo_add_localization
ChatGPTTranslate every card's copy into a locale with Claude (or store provided copy) — the default published demo then swaps to the viewer's language on arrival (localized-on-arrival). Locale is a BCP-47-ish tag: ja, de, pt-BR. Re-running a locale overwrites its draft.
rendemo_add_sandbox_demo_step
ChatGPTAppend a step to a hosted SANDBOX DEMO. Choose the target from rendemo_list_sandbox_pages plus rendemo_find_in_sandbox or rendemo_read_sandbox_page; the server stores durable element facts and re-resolves them after rebuilds. This tool never returns a marker to write into customer source. Use rendemo_add_tour_step only for codebase tours.
rendemo_add_tour_step
ChatGPTAppend a step to a CODEBASE TOUR and return the exact data-rendemo attribute to write into customer source. Read the tour-craft skill first. For a hosted sandbox demo, use rendemo_add_sandbox_demo_step instead. The optional sandbox input remains accepted only for older clients and creates a sandbox-demo step; new agents must not use it.
rendemo_add_video_shot
ChatGPTInsert a brand-new shot (beat) into the video cut at a point in time — for a moment worth its own hold that the recording didn't naturally break into one. Starts full-frame; pass shot ('wide'/'medium'/'punch'/'auto') to also frame it like rendemo_frame_video_shot would (only takes effect if the moment has a recorded element to frame on). Keeps shots in time order. To break an EXISTING shot into two instead, use rendemo_split_video_shot.
rendemo_annotate_shot
ChatGPTDraw a callout / feature / box / ellipse / arrow / line / spotlight on one shot — it shows in the video (and demo) for that beat's duration. rect is a content-% box (x,y,w,h in 0-100, the same space as the shot framing). 'callout' shows text with an optional leader line to target; 'feature' is a designed b-roll card (bold title + optional body line, accent bar) anchored at the rect — the pro way to name a feature on screen; 'spotlight' dims everything outside the rect; box/ellipse outline the rect; arrow/line point across the rect's diagonal. One idea per moment — use on the payoff, not every shot.
rendemo_apply_brand_style_default
ChatGPTMerges this workspace's saved default video style into THIS project's plan.videoStyle. By default the project's existing overrides win (only fields the project hasn't set are filled in from the default) — pass force:true to let the default win instead, overriding fields the project already set. Fails with a clear message if no workspace default has been saved yet (see rendemo_save_brand_style_default).
rendemo_apply_custom_design
ChatGPTApplies a card, emphasis or pointer saved in the workspace library to one step. Use rendemo_list_presentation_recipes to discover ids. A coded card replaces the step's recipe rendering, and also sets the emphasis mode and marker the design was drawn against where it declares them; a coded emphasis or pointer replaces the step's emphasis mode and marker entirely.
rendemo_apply_motion_preset
ChatGPTQuick way to switch the kinetic-text entrance motion: 'reveal', 'rise' (default — the safe premium choice), 'draw', 'type', or 'fade'. Set resetParams:true to also clear any custom duration/ease/stagger/direction/mask overrides so the preset's own defaults take over.
rendemo_apply_presentation_direction
ChatGPTApplies an approved recipe sequence while preserving copy, interactions, branches, narration, hotspots, and analytics identifiers.
rendemo_apply_step_presentation_style_to_all
ChatGPTCopies the source step's material, compatible motion, typography, per-block text formatting, and border to every demo card while preserving each step's recipe, composition, content, target relationship, branching, media, and analytics identity.
rendemo_apply_video_preset
ChatGPTApply title and end cards when missing, enable background music and captions, and set tight pacing, click effects, and section transitions for rendered video. Existing title and end cards are preserved unless force:true. An explicit effects.motionBlur:false is preserved; motion blur is supported by the motion engine but does not render on the cinematic engine's locked camera. These settings affect video output only. For interactive demo appearance use rendemo_style_steps, rendemo_update_step, or rendemo_auto_direct. Pass preview:true to report proposed changes without saving. Saves a project revision when applied; rendemo_queue_video_render starts the separate render job.
rendemo_apply_video_treatment
ChatGPTOne move to set a coherent, professional feel across the whole cut — the fix for a snappy/over-zoomed/warpy video. 'calm'/'professional': gentle pacing (max 4x), subtle glow effects, camera motion blur on fast moves, quiet sound, AND pulls every over-zoomed shot (zoom > 2) back to a calm medium framing. 'dynamic': punchier pacing + effects + motion blur (leaves your shots alone). 'minimal': real-time pacing, no effects, resets ALL shots to full frame — and resets effects to their defaults, INCLUDING clearing an explicit motionBlur:false. An explicit effects.motionBlur:false set via rendemo_tune_video survives 'calm'/'professional'/'dynamic', but 'minimal' wipes the slate and a LATER treatment re-applies its own mix (blur back on) — re-set motionBlur:false after it if you want blur kept off. After a treatment, selectively rendemo_frame_video_shot 'punch' the 1-2 real payoff moments.
rendemo_auto_author_sandbox_demo
ChatGPTFrom a BUILT sandbox to a finished, anchored demo. Call it once with no steps and it returns the elements worth a step — headings, the numbers the page is claiming, the calls to action, with nav, footers and cookie banners refused outright. Choose 4-7, then call again with steps and it writes them, each with camera framing and a real DOM effect already set (a metric counts its own number up, a section reveals, a cta pops). YOU write the arc and the copy, so it runs on your model rather than a server-side API key. Every target is re-checked against the shortlist, so a step can only point at an element that exists. Pass useServerModel:true only for a pipeline with no agent in the loop — that bills the workspace's Anthropic key. Publish afterwards with rendemo_publish_sandbox then rendemo_publish_demo.
rendemo_auto_direct
ChatGPTOne deterministic directing pass over every visible step: hero moments (high recorded salience) get a punch-in, ordinary actions a medium frame, and every card is placed beside its target instead of on top of it. Steps where the author hand-placed the card or hand-zoomed are left alone unless force=true. Run rendemo_director_lint afterwards to verify. Cheap by construction — pure geometry, no model calls.
rendemo_capture_pages
ChatGPTCapture named pages of a signed-in product into a browser crawl WITHOUT the user clicking per page. Requires a crawl from rendemo_start_browser_crawl whose capture code the user has pasted into the Rendemo Chrome extension: from then on the extension opens each url you pass in their signed-in tab, captures it, and reports back. Pass full urls on the crawl's origin; logout/delete-shaped paths are refused, and a page that lands on a login wall is refused and named rather than captured. HOLDS THE CONNECTION OPEN (default 90s) while pages are captured and returns per-url results plus whether the extension has joined at all — the difference between 'nobody pasted the code' and 'working'. If pages are still in flight when it returns, CALL IT AGAIN WITH NO urls — that is not a stopping point. Then rendemo_finish_browser_crawl. The user can still click 'Capture this page' for pages you cannot name; rendemo_watch_captures counts everything that reached storage either way.
rendemo_check_sandbox_demo
ChatGPTFor a SANDBOX DEMO only: re-scores every authored step's stored facts (from rendemo_add_sandbox_demo_step) against the source sandbox's CURRENT pages and reports, per step, whether it would still resolve — without writing anything. RUN THIS after any sandbox rebuild (a re-recording, a re-extraction) and before publishing: a rebuild renames files and can reflow the DOM enough that a step which resolved yesterday scores differently today, and this is how that is caught before a visitor is. Uses the SAME scoring the real stamping pass (at publish, and again after every rebuild) uses, so a step reported 'resolved' here will stamp, and one reported 'ambiguous' or 'absent' will not. 'resolved' names the winning element's node id and score. 'ambiguous' means two elements were too close to call — the runner-up's score is included so you can judge how close, and how to make the target more specific (an id, a data-testid) to break the tie. 'absent' means nothing scored high enough — most often the element is gone from the current sandbox, or the sandbox itself is not built or not in this workspace. Codebase-tour steps added with a plain route are skipped; this tool refuses when the project has no sandbox-demo steps.
rendemo_clear_interludes
ChatGPTRemove section interlude (chapter) cards — all of them, or only those at a given atSection index.
rendemo_clear_shot_annotations
ChatGPTRemove one annotation (pass annotationId) or all annotations from a shot. Use rendemo_get_video_plan / the editor to find ids.
rendemo_clear_video_sections
ChatGPTRemove one speed/cut section by index (pass index) or ALL sections (omit index). Use rendemo_get_video_plan's settings.sections to find indices.
rendemo_configure_lead_capture
ChatGPTThe demo's conversion moment: a gate at start/end (or at a step), and/or the in-card inline email form at a chosen step (capture at peak intent, no gate). Sets every string the gate renders, including the privacy line and the post-submit confirmation. Leads flow to the dashboard, webhooks, and CRM integrations with step context. Pass enabled=false to remove capture entirely.
rendemo_crawl_site
ChatGPTCrawl a site's PUBLIC pages (via sitemap.xml) with headless Chrome and build a Rendemo sandbox from it. THIS IS THE WEAKEST OF THE THREE CAPTURE ROUTES and the right one only when the demo genuinely IS a public website. BEFORE CALLING, ASK TWO QUESTIONS. Is this a product? Then the user should RECORD it with the Rendemo Chrome extension ('Record this tab', then 'Stop' and 'Send to Rendemo') — that captures real interaction and real data instead of a static replica of what a stranger's bot can fetch, and auto-direction runs on upload; see the new-demo skill. And must the demo show anything behind a login (their dashboard, their account, their data)? Users rarely volunteer this, and the public marketing site is rarely what they meant — if yes or unsure, use rendemo_start_browser_crawl instead, which handles signed-in capture through the user's own browser. Having no browser tools of your own is NOT a reason to prefer this tool: the user has a browser and drives all three routes. Returns a job id: poll it with rendemo_get_crawl_status, which reports the crawl AND the sandbox build that is chained behind it automatically. This is SLOW — a crawl typically takes a few minutes (40 pages took 239 seconds in production) and the sandbox build takes several more — so poll every 15-30 seconds and trust the tool's elapsedSeconds rather than your own sense of time. Pass projectId to RE-crawl an existing crawl-sourced project, which keeps its sandbox id and slug so already-authored demos keep working. Pass urls to name the exact pages to visit — that SKIPS sitemap discovery entirely — but it still fetches anonymously, so pages behind a login come back as sign-in screens. FOR SIGNED-IN PAGES use rendemo_start_browser_crawl instead — it works even with no browser tools of your own (the user captures pages with the Rendemo extension via a capture code). The url you pass is always visited too, path and all. The resulting sandbox is NOT published: publishing stays a separate, deliberate step. IF THIS CRAWL WILL BECOME A SANDBOX DEMO, read the sandbox-demos skill (rendemo_load_craft_skill) while it runs — a sandbox demo writes no markers into customer source and is not a codebase tour.
rendemo_create_sandbox_demo
ChatGPTCreate a hosted SANDBOX DEMO backed by a crawled replica. This is a demo viewers watch and share, not a codebase tour: it writes nothing into customer source and has no lockfile. BEFORE styling anything, ask the USER what vibe and motion they want — the sandbox-demos skill carries the exact questions and the theme menu; never pick a look silently. Survey the source sandbox first, add steps with rendemo_add_sandbox_demo_step, validate with rendemo_check_sandbox_demo, then publish the source sandbox followed by this demo.
rendemo_create_tour
ChatGPTCreate a TOUR — step-by-step guidance on the user's OWN product, which they perform for real. No recording: each step is anchored to a data-rendemo marker you write into their source. Returns the tour slug to use in every marker. Add steps with rendemo_add_tour_step, preview it with rendemo_get_tour_preview, then publish; only published tours run for visitors. If the user instead wants something a visitor WATCHES, that is a demo — record and publish one, then install it with rendemo_get_embed.
rendemo_create_tracking_link
ChatGPTA campaign-attributed share URL for the published demo (views, completion and leads segment by campaign in analytics). Returns the /t/<token> URL to share.
rendemo_delete_video_shot
ChatGPTHARD-remove a shot (beat) from the video cut — it's gone from the plan entirely. Contrast with rendemo_set_video_shot enabled:false, which cuts a shot from the video but keeps it (restorable by re-enabling). Fails if it's the only shot left, or the id doesn't exist.
rendemo_design_brand_style
ChatGPTAsks an LLM to propose a complete on-brand kinetic-text style (type/color/motion/layout) from the project's brand kit (accent + heading/body fonts) — a one-shot 'design my style' instead of setting each field by hand. Deep-merges the result into plan.videoStyle: by default the author's existing overrides win over the new design (only unset fields get filled in); pass force:true to let the new design override existing fields too. Pass saveAsDefault:true to also make this the WORKSPACE default (see rendemo_save_brand_style_default) so future projects inherit it. Falls back to a deterministic template style if no AI key is configured. Use rendemo_get_video_style afterward to see the resolved result, or rendemo_set_video_style/rendemo_apply_motion_preset to hand-tune it further.
rendemo_design_card
ChatGPTWrites one step's card yourself, in CSS. Call it WITHOUT css to get the full design brief — the runtime contract, the live slots, the brand tokens, the motion rules and the per-step target variables — then call it again with the CSS you wrote, which is validated and applied. This is the escape hatch the scene axes cannot cover, and it is the same brief the Studio hands Claude. layout designs the card's own DOM and keeps it editable; composable styles the existing anatomy; raw replaces the markup and gives up the inspector's controls.
rendemo_direct_step
ChatGPTSet the camera shot and card position for one interactive-demo step. shot: 'wide' (full frame), 'medium' (~1.7x frame on the target), 'punch' (~3x hero close-up), 'auto' (from the step's recorded salience). cardAnchor: a corner/center, or 'auto' to place the card beside the highlighted element without covering it. The deterministic solver computes exact geometry from the captured element box — results land in the same fields the editor's drag/zoom controls use, so the author can adjust by hand afterwards.
rendemo_director_lint
ChatGPTZero-cost audit of a demo's direction AND its content, PLUS the resolved choreography of every step — whether it holds still or moves, both framings of each move, and why a move was dropped. GEOMETRY: cards covering their own target, crops that cut off the highlighted element, off-stage cards, disorienting zoom depths, long copy over tight shots. CONTENT: a CTA wired to nothing, an emphasis colour no viewer can see, placeholder copy, internal hostnames, card imagery with no alt text, an unused brand, and orphaned or dangling steps in a branching demo. Two rules block (a dead CTA and an invisible mark); the rest are warnings. Run after directing or copy changes. THIS IS GEOMETRY, NOT LEGIBILITY: it passes while a card is unreadable over a busy region or covers the very element it points at, because it never sees the demo. To actually LOOK at it, publish and call rendemo_review_demo_frames, which returns real screenshots of each step.
rendemo_drive_click
ChatGPTClick one control identified by CSS selector or visible text. Destructive-looking targets are refused, but an accepted click can still change external website data. Requires rendemo_start_drive_session and the user's connected tab. Rehearsal is not recorded. Returns the page observation after this operation.
rendemo_drive_navigate
ChatGPTNavigate to one URL on the session origin. Logout and delete-shaped paths are refused. Navigation can affect the external website's state. Requires rendemo_start_drive_session and the user's connected tab. Rehearsal is not recorded. Returns the page observation after this operation.
rendemo_drive_read
ChatGPTRead a compact page outline, optionally restricted to a CSS-selected subtree. Queues an observation command in the connected session and returns visible controls and their selectors. Requires rendemo_start_drive_session and the user's connected tab. Rehearsal is not recorded. Returns the page observation after this operation.
rendemo_drive_scroll
ChatGPTScroll the page in a direction by an optional amount, or bring one CSS-selected element into view. Requires rendemo_start_drive_session and the user's connected tab. Rehearsal is not recorded. Returns the page observation after this operation.
rendemo_drive_type
ChatGPTType text into one CSS-selected field, optionally pressing Enter. Password fields are refused. Typing or submission can change external website data. Requires rendemo_start_drive_session and the user's connected tab. Rehearsal is not recorded. Returns the page observation after this operation.
rendemo_drive_wait
ChatGPTWait a bounded number of milliseconds for the page to settle, then return its observation. Requires rendemo_start_drive_session and the user's connected tab. Rehearsal is not recorded. Returns the page observation after this operation.
rendemo_export_offline
ChatGPTA time-limited download link for the published demo as one self-contained offline HTML file (replay, styling, interactions and media embedded). Publish first.
rendemo_find_in_sandbox
ChatGPTGrep ONE sandbox page — get its file name from rendemo_list_sandbox_pages first, this tool does not search across pages. pattern is a LITERAL substring, matched case-insensitively, never a regex — paste back text you just read (a button's label, a fragment of an href) without escaping anything. Every hit carries the line it lives at, for a follow-up rendemo_read_sandbox_page call, AND a nodeId: the durable address a sandbox-demo step names as its target. Search always runs over the WHOLE page, never just the default 200-line read window, so this finds text a plain read at the top of the page would miss.
rendemo_find_real_data
ChatGPTRead-only. Sweeps the recording for real data a viewer would see -- people's names, handles, emails, and the image sources next to them -- and reports them CLUSTERED BY REGION rather than as loose hits, with up to 3 samples and a count for each (never the full list of real values -- this tool is not a place to bulk-read a customer's data). This is what to call before publishing anything built from a real account: a lead list, an inbox, a CRM screen. Pair with rendemo_seed_data to replace what it finds -- pass the SAME path back with a type: a personName cluster seeds as type:"person", imageSrc (reported here as photographs) seeds as type:"avatar", and handle/email keep their own name -- the two tools' vocabularies differ only for those two kinds. If the recording is large, the sweep can stop early -- the result's capped flag and its own text say so plainly when it happens, because a partial sweep that reads as complete is exactly the failure this feature exists to prevent: a region past the cap having no finding is NOT evidence it is clean.
rendemo_finish_browser_crawl
ChatGPTClose a browser crawl started with rendemo_start_browser_crawl and queue the sandbox build from the pages you posted. Returns a job id — poll it with rendemo_get_crawl_status exactly as you would a headless crawl; the build is the same one, and it is chained automatically. Pass pagesCaptured so a page that failed to upload is reported rather than silently missing from the sandbox. The count is CHECKED against what reached storage before anything is queued: if nothing landed this refuses, and it never confirms a number it has not verified.
rendemo_finish_drive_session
ChatGPTClose a drive session: cancel anything still queued and tell the extension to end it — if a take is rolling it stops and uploads (auto-directing like a hand recording); if it was only rehearsing, the session simply ends. You do not need this after rendemo_record_drive_plan, which stops the take itself. Use it to abandon a rehearsal or to stop a take early. Then rendemo_watch_captures if anything was recorded. Cancelled queued actions cannot be resumed, and stopping a take early ends the remaining recording.
rendemo_frame_video_shot
ChatGPTFrame one video shot on its recorded element — 'wide' (full frame), 'medium' (~1.7x on the element), 'punch' (~3x hero close-up), 'auto' (from salience). Deterministic solver from the captured element box (no vision). Writes beat.crop, the same field the editor's reframe/zoom write.
rendemo_generate_narration
ChatGPTRun the deterministic story pass over the cut: assign each shot a story intent (hook/establish/action/detail/payoff/breather — this also tells the camera which shots should breathe) and enable captions. Chapters are marked by animated on-screen section titles over the footage automatically (from the establishing shots) — the produced-film look — so you do NOT need chapter cards for that. Set addChapters:true only if you specifically want full-frame interlude slides (a slideshow-style interrupt) instead. Never overwrites shots/cards you've hand-edited. A good first move on a raw capture before fine-tuning.
rendemo_get_brand_style_default
ChatGPTRead this workspace's saved default on-brand kinetic-text style (set via rendemo_save_brand_style_default or rendemo_design_brand_style saveAsDefault:true) — the style new projects inherit and rendemo_apply_brand_style_default applies to an existing one. Returns null when nothing has been saved yet.
rendemo_get_crawl_status
ChatGPTStatus of a crawl queued with rendemo_crawl_site, and of the sandbox build it chains. THIS TOOL WAITS: it holds the connection open (30s by default, up to 120) and returns when the state actually moves, so one call covers what used to take several. It reports the crawl's progress and phase, an authoritative server-computed elapsedSeconds, then the sandbox job and demo id once the crawl finishes, plus authenticated (whether a shared session was used) and walledPages (urls dropped as login walls), and a nextStep saying plainly what to do now. IF IT COMES BACK STILL RUNNING, CALL IT AGAIN IMMEDIATELY with the same jobId — that is not a stopping point and not something to report to the user. Ending your turn there abandons the crawl: nothing resumes it, and the person is left waiting for a result that already arrived. A crawl typically takes a few minutes (40 pages took 239 seconds in production) and the sandbox build takes several more, so expect a handful of calls.
rendemo_get_decision_log
ChatGPTThe audit trail of every AI-made change (copilot and MCP): directing calls (camera shots, card placement), copy rewrites, emphasis/design updates, publishes — each with its arguments and outcome. Read it BEFORE re-directing or re-diagnosing a demo so you build on (or deliberately reverse) earlier decisions instead of repeating them.
rendemo_get_demo_analytics
ChatGPTThe published demo's funnel: viewers, completion, per-step drop-off, CTA rate, campaigns, per-variant outcomes with the current best performer, and lead count. The starting point of every improve-the-demo loop.
rendemo_get_embed
ChatGPTEverything needed to install a published demo on a website: the script tag and where it goes for this framework, the markup, and the source of a local wrapper component. The demo must be published first. Write the returned files yourself — this tool cannot touch your filesystem.
rendemo_get_journey
ChatGPTThe demo's step graph: linear flow, branch edges (card choices + goto hotspots), unreachable steps and dangling branch targets. Use before/after editing choices.
rendemo_get_narration_status
ChatGPTRead one workspace-owned speech synthesis job. done means the generated WAV and caption words were attached to the project; error includes the reason speech or revision validation failed.
rendemo_get_plan
ChatGPTThe demo plan as an agent needs it: every step in play order with its role, emphasis, marker, card variant and recipe, target geometry, framing authorship, viewport overrides, and whether a sandbox demo step carries a camera move. It also reports unbound recorded targets, plus demo-wide presentation, guide, choreography, lead-capture and playback settings. Read this before styling so you do not set something the runtime will discard.
rendemo_get_render_status
ChatGPTRender execution outcome, progress, output availability, warnings, and publication state. A completed unpublished video has legacy status 'draft'. Partial exports are failures to complete and cannot be published. Pass renderId or omit for recent renders.
rendemo_get_sandbox_demo_preview
ChatGPTReturn a ready-to-open, 30-minute bearer link for the CURRENT DRAFT of a hosted sandbox demo. It opens on Rendemo's workspace host, carries a persistent Preview badge, publishes nothing, records no analytics, and requires no customer source markers. Run rendemo_check_sandbox_demo first.
rendemo_get_tour_lockfile
ChatGPTThe exact contents of rendemo.tours.json for a PUBLISHED tour. Write this file to the repo root and commit it — the rendemo CLI reads it offline in CI to verify every step still has a marker in source. That CLI is published on npm, so npx rendemo check works with no install (needs rendemo@0.2.0 or newer for the rendemo.tours.json name). IMPORTANT: if the repo already has a lockfile — rendemo.tours.json, or the older rendemo.flow.json — read it and pass its text as lockfile — one file describes EVERY tour in the repo, and writing a single-tour file silently stops checking the others.
rendemo_get_tour_preview
ChatGPTA ready-to-open URL that runs the tour's CURRENT DRAFT on the user's own running app — before publishing, and without publishing. Open it in a browser pointed at their app (a dev server, a staging deploy, production) and the tour appears, with a persistent "Preview" badge on every card so a draft is never mistaken for the live thing. Nothing is published, no analytics are recorded, and progress is kept out of a real visitor's storage. SHARE IT CAREFULLY: the link is a bearer token — anyone who opens it sees the draft, with no sign-in — and it expires 30 minutes after it is issued. THE LIMIT WORTH SAYING OUT LOUD: the data-rendemo markers must already exist in the BUILD being previewed. Against a dev server that is immediate (save the file). Against a staging or production URL, the commit that adds the markers has to be deployed there first, or every step will report that it cannot find its target. RUN rendemo_probe_tour_targets FIRST. It answers that from the host itself, in seconds and without spending any of this link's 30 minutes — and the clock here starts the moment the link is issued, so mint it when the reviewer is ready to look, not before a build or an install.
rendemo_get_video_plan
ChatGPTThe video output's full cut sheet: every shot (beat) with its timing, zoom depth, transition link, salience, story intent and annotations, plus the plan-level pacing, click effects, sound mix, caption state, trim (in/out) and speed sections — the WHOLE video is viewable here. Read this BEFORE adjusting shots — 'improve the video' means these levers (then rendemo_frame_video_shot / rendemo_set_video_shot / rendemo_add_video_shot / rendemo_split_video_shot / rendemo_delete_video_shot / rendemo_apply_video_treatment / rendemo_tune_video / rendemo_trim_video / rendemo_set_video_speed_section / rendemo_clear_video_sections), not the demo card tools. CRAFT: a polished cut is mostly wide/medium — punch only the 1-2 payoffs, hold shots ~3s, one move per shot, gentle pacing (over-zoom + high maxSpeed is what reads snappy/warpy). Load the video-craft skill with rendemo_load_craft_skill before a real polish pass.
rendemo_get_video_style
ChatGPTRead the on-brand kinetic-text style for auto section titles/feature callouts/cards: both the plan's raw overrides (videoStyle) and the fully resolved style (defaults + theme accent filled in). Use before rendemo_set_video_style to see what's currently in effect.
rendemo_group_steps
ChatGPTCombine consecutive recorded actions into one interactive stop. The viewer activates the lead, then the complete original action interval plays before the next result. Keeps every video beat and window unchanged. Members must include the lead first and every intervening recorded interaction; result scenes cannot be grouped. Preview is the default. Pass remove:true to restore an existing group's members.
rendemo_list_leads
ChatGPTCaptured leads for a project's demo, with the step each in-card lead converted at (intent depth). Read-only; emails are viewer PII — handle accordingly.
rendemo_list_presentation_recipes
ChatGPTReturns the WHOLE card vocabulary: the five forms, the grades, marks, ties, reveals and entrances, the scene's two continuous scalars, and the workspace's own saved designs. There is one vocabulary — a step's look is its scene, and nothing else sets it.
rendemo_list_projects
ChatGPTList the workspace's demo projects (newest first): id, name, step count, published demo url when live, and whether the demo is password-protected. Start here to find the projectId every other tool needs.
rendemo_list_revisions
ChatGPTEvery saved state of this project's plan, newest first — what each one was labelled, who wrote it, and when. A revision holds the plan as it was BEFORE the write that created it, which is the state rendemo_restore_revision goes back to. Every mutating MCP tool writes one labelled with its own name, so a pass you regret is findable by the tool that made it.
rendemo_list_sandbox_pages
ChatGPTEvery page in a SANDBOX replica — a free-roam, byte-accurate rebuild of a recorded product, extracted from a screen recording rather than read from a customer's own repo. Returns each page's file name (the exact address rendemo_find_in_sandbox and rendemo_read_sandbox_page expect), the URL it was recorded from, its size in bytes, and which ONE is the entry page a visitor lands on first — bytes comes back null for a page storage could not answer for right now, without failing the rest of the list. Sizes only: this tool never opens a page, so it cannot tell you what is ON one. Pick a page by its recorded URL and size, then call rendemo_find_in_sandbox or rendemo_read_sandbox_page, which report that page's line count as totalLines. A sandbox can carry dozens of pages and any single one can reach several megabytes, so START HERE before grepping or reading anything — this tool is how you decide WHICH page to look at, not what is on it. THIS LIST IS THE WHOLE WORLD: a page not in it does not exist for a sandbox demo, and a sitemap crawl routinely misses everything behind a login or rendered only after an interaction — so read it as what the demo CAN be about, before committing to a sequence. Read the sandbox-demos skill (rendemo_load_craft_skill) now: it covers choosing steps worth taking and elements that survive a rebuild, both of which happen before rendemo_add_sandbox_demo_step. If demoId names a codebase-tour project, there are no pages here — use rendemo_get_plan and the customer's own source instead.
rendemo_list_tours
ChatGPTEvery TOUR in this workspace: projectId, name, tour slug, step count, and whether it is currently live. Start here for any change to an existing tour — adding a step, rewording one, reordering, or removing one. Replay demos are deliberately excluded; they are a different artifact and rendemo_list_projects covers those. With a projectId in hand: rendemo_get_plan for the step ids, rendemo_add_tour_step to append, rendemo_update_step to reword, rendemo_reorder_steps to reorder, rendemo_remove_tour_step to drop one, rendemo_unpublish_tour to retire the whole thing.
rendemo_list_tracking_links
ChatGPTExisting campaign links for the project's demo, with view counts.
rendemo_load_craft_skill
ChatGPTRendemo's own direction and taste for a given kind of work, as a skill document. Read the relevant one BEFORE a polish, restyle, re-direct or "make it look professional" pass — each carries the treatments that actually exist, the combinations the runtime rejects, and the rules that silently discard a change you thought you applied. Cheap, read-only, no project needed. - brand-and-look — Choose or change demo-wide themes, brand styling, backdrops, card design, or video text styling. - camera-direction — Frame shots or repair camera movement in recorded demos and rendered videos, including ignored moves. - demo-craft — Polish recorded interactive demo steps, including scenes, emphasis, copy, effects, and product data. - drive-and-record — Rehearse and record a signed-in product walkthrough when the user wants the agent to drive their browser. - new-demo — Create a Rendemo demo when no project exists, choosing capture and building the requested result from chat. - sandbox-demos — Create or edit hosted sandbox demos from crawled replicas, including durable targets and rebuilds. - tour-craft — Polish live codebase tour cards, emphasis, magnified lenses, and data-rendemo target resolution. - video-craft — Improve a rendered video cut through pacing, framing, music, captions, titles, and cinematic packaging.
rendemo_probe_tour_targets
ChatGPTFetches every step's route from the user's running app and reports, per step, whether the tour would find its marker there. RUN THIS BEFORE rendemo_get_tour_preview: it catches the failures a preview would otherwise spend the reviewer's time (and the link's 30-minute clock) discovering — markers not deployed to that host, a route that renders a sign-in stub, a marker that resolves to several elements with no match. HOW TO READ 'absent': the probe sees the HTML the server sends a SIGNED-OUT stranger. A marker rendered after sign-in, or only on the client after hydration, is genuinely missing from that response and genuinely present for the real visitor. So 'absent' means look here, not broken — and knowing WHICH steps need a signed-in session is exactly what makes the preview review efficient rather than confusing.
rendemo_promote_staged_sandbox
ChatGPTApply a STAGED re-crawl to the live sandbox: its pages are copied over the live replica and every viewer sees the new crawl from that moment. THIS REPLACES WHAT THE WORLD ALREADY SEES at a public URL, with a fresh recording of a site that may have changed since anyone approved it. Call rendemo_review_staged_sandbox FIRST, and only call this once a human has actually reviewed the staged build — a redaction report with no concerns is not a review, because the detector does not flag a bare personal name at all. acknowledgeReviewedStagedBuild must be true and is the claim that this happened. Promotion re-verifies server-side that the staged pages are marked redacted and refuses if they are not — a hard gate with no override. It does not publish or unpublish anything and spends no published-artifact budget: the sandbox was already live, this only changes which build is. NOT REVERSIBLE — the previous build is not kept. Re-crawl to change it again.
rendemo_propose_drive_plan
ChatGPTStore a proposed recording plan for display in the Rendemo extension; this call executes no website actions and starts no recording. Each step uses an operation individually exposed as rendemo_drive_navigate, rendemo_drive_click, rendemo_drive_type, rendemo_drive_scroll, or rendemo_drive_wait. Write an ordered list of visible steps along one path to the outcome, each with a one-sentence purpose that says what the viewer learns. Five to ten steps. Every step passes the same safety gate as a live action, and the extension stores the plan so its popup can show 'Record the plan'. Returns the plan rendered as a numbered list: SHOW IT TO THE USER and ask them to approve or change it before you record anything. Propose again to replace it. Then rendemo_record_drive_plan.
rendemo_publish_demo
ChatGPTBuild and publish an interactive demo (recorded or sandbox-backed) and return its public URL. Publishing an already published project replaces its current public artifact, and the prior artifact may not be recoverable. Confirm the user's publication request before calling. Also publishes codebase tours, which run inside the customer's product and return no hosted URL.
rendemo_publish_sandbox
ChatGPTPut a SANDBOX on the air. This makes the replica WORLD-VISIBLE: anyone with the URL, signed in or not, can browse every page in it. AUTHORING A SANDBOX DEMO DOES NOT NEED THIS — rendemo_list_sandbox_pages, rendemo_find_in_sandbox, rendemo_read_sandbox_page and rendemo_add_sandbox_demo_step all work on an unpublished sandbox, so never publish merely to author or check a demo. Publishing re-verifies server-side that the sandbox's pages are marked redacted, and refuses if they are not — a hard gate with no override. It also draws on the plan's published-artifact budget, which demos, codebase tours and sandboxes share. Returns the public url and the shareable short URL. Reversible with rendemo_unpublish_sandbox.
rendemo_queue_video_render
ChatGPTRender the project as a video (mp4 or gif) on the render worker. Returns a renderId to poll with rendemo_get_render_status. Takes minutes. stepMs sets one flat hold per step for this export only; omit it and each step is held for as long as its own card takes to read, which is usually what you want.
rendemo_read_sandbox_page
ChatGPTA bounded, line-numbered view of ONE sandbox page — get its file name from rendemo_list_sandbox_pages first. A captured page can reach several megabytes, so this NEVER returns the whole document: at most 400 lines per call, 200 by default. offset is the 1-based line to START AT — 1 shows the top of the document, not the second line. Read totalLines back, and if it is bigger than the last line you were shown, call again with offset set just past it. Each line is one element's start tag — attrs verbatim — indented by nesting depth, plus that element's own leading text, and carries the nodeId a tour step would target. Prefer rendemo_find_in_sandbox when you already know the text you are looking for; reach for this when you need to see the STRUCTURE around a spot, or are paging through a page you have not looked at yet.
rendemo_record_drive_plan
ChatGPTRecord the already stored and acknowledged plan from rendemo_propose_drive_plan. Accepts no new actions, script, or arbitrary command. The plan contains only operations individually exposed as rendemo_drive_navigate, rendemo_drive_click, rendemo_drive_type, rendemo_drive_scroll, and rendemo_drive_wait. The user opens 'More ways to create' → 'Let your AI drive' and clicks 'Record the plan' in the extension popup (Chrome needs their click to start the tab recorder); the extension then executes the steps back-to-back with a short settle after each, stops, and uploads the take, which auto-directs like a hand recording. The steps interact with the connected external website and can change its data. Call this only after the user approved the plan. It HOLDS OPEN until the take is done; if it comes back still recording or waiting for the click, call it again — not a stopping point. When it reports done, rendemo_watch_captures (no crawlId) picks up the project.
rendemo_remap_after_recapture
ChatGPTREAD-ONLY. Given a project and a second project holding a NEW recording of the same product, reports what would carry across: card copy, camera framing and hotspots, each with a confidence and the evidence behind it (a unique element label, a shared one, or merely position in the recording). It applies NOTHING and there is no argument that makes it apply. Redaction rectangles and product-data replacements are never proposed for migration at any confidence — a redaction that lands on the wrong element publishes the thing it was hiding, and that failure is invisible from looking at the demo. Those are listed as unresolved, and a publish is refused until a person has re-made or dismissed each one. Show the queue to the author; applying is theirs.
rendemo_remove_tour_step
ChatGPTDelete one step from a tour AND get back the data-rendemo marker you must strip from source in the same change. THIS IS NOT OPTIONAL: leaving the marker behind makes rendemo check fail the build with an orphan-marker, so removing the step without removing the attribute breaks CI for whoever pushes next. Present both edits as one reviewable diff. Afterwards the tour must be published again (rendemo_publish_demo) and the lockfile regenerated (rendemo_get_tour_lockfile) — until then the committed lockfile still describes the step you removed. Refuses when another step's branch choice points at this one, because a dangling choice is dropped silently rather than reported, and refuses on the last remaining step (use rendemo_unpublish_tour to retire the whole tour).
rendemo_render_step_card
ChatGPTThe actual HTML of one step's card — composed by the same renderer the player and the live tour use, with its own scoped stylesheet and no external references. Pass variants to render several candidate looks of the SAME step side by side (different recipe/material/emphasis, optionally different copy) and choose by looking rather than by publishing. Each variant reports whether the runtime would actually accept it: a recipe carries a role constraint and a copy budget, and a refused combination is returned with the reason instead of a card that could never ship. Returns every variant on one comparison page as well as one embedded HTML resource per card. Clients may render or save those resources according to their supported MCP resource behavior.
rendemo_reorder_steps
ChatGPTSet the demo's play order. Pass the COMPLETE ordered list of step ids from rendemo_get_plan (a partial list drops the missing steps from the story order).
rendemo_republish_all
ChatGPTRe-bake every PUBLISHED demo in this workspace so they pick up player fixes. The player runtime is baked into each artifact at publish time, so a deployed fix -- a redaction change, corrected copy, an accessibility fix -- is invisible on demos that already exist until they are republished. This is the only bulk path. It never publishes anything that was not already published: it refreshes live artifacts at their existing public URLs, replacing what viewers currently see. The prior published artifact may not be recoverable. Returns a jobId; poll it with rendemo_get_crawl_status. Pass dryRun to count what would be rebuilt without rebuilding it.
rendemo_restore_revision
ChatGPTPuts the plan back to a saved revision — the undo for a pass that went wrong. Find the id with rendemo_list_revisions. Call with preview first to see what restoring would change; a restore is itself a write, and it writes its own revision before it, so nothing is lost either way. It restores the PLAN only: a published demo keeps serving its existing artifact until you publish again.
rendemo_review_demo_frames
ChatGPTSEE the saved draft privately (default), or pass source=published to review the live artifact. Freezes the draft without publishing, opens each scene in a real device viewport, and returns real screenshots as images you can look at — then fix what is actually wrong and republish. This is the only check that can catch an unreadable card, a card covering its own target, or emphasis that renders invisibly: rendemo_director_lint reads geometry and passes on all three, and rendemo_render_step_card draws the card over a stand-in shell rather than the real screen. Photographs up to 6 steps per call — pass steps to choose which, and call again for the rest. IT WAITS (up to 120s) while the worker drives a real browser; if it comes back still running, call it again immediately with the jobId it gives you and do not end your turn. Returns exact saved plan/renderer provenance, stable scene IDs, and per-scene capture failures. Stills verify appearance and scene identity, not motion, privacy completeness, or business outcomes.
rendemo_review_project
ChatGPTPre-publish review: per-step sign-off states, untitled steps, missing lead capture, and step/lead totals. The launch-checklist tool.
rendemo_review_staged_sandbox
ChatGPTCheck whether a re-crawl is STAGED for a sandbox and read its redaction review. Re-crawling a sandbox that is already PUBLISHED does not replace the live pages — it writes a staged build and leaves the live replica exactly as it was, so a fresh crawl of a site that may have changed cannot go world-visible without a human looking at it first. This tool is how you look. Reports whether a staged build is pending, when it finished, its page count, what the redaction pass found, and any concerns raised. A CLEAN REPORT IS NOT A REVIEW: the detector only flags a person's name when it sits beside a dollar amount, so an all-zeros report routinely rides along with real names still in the pages. Read pages with rendemo_read_sandbox_page, or have a human look, before promoting. Read-only — it changes nothing. Apply the staged build with rendemo_promote_staged_sandbox.
rendemo_review_step_presentations
ChatGPTReturns deterministic copy, content, role, responsive, accessibility, repetition, and narrative-rhythm findings plus a signed real-render review URL. Content findings are the SAME rules the publish gate enforces, each tagged blocking or warning, so this says in advance what a publish will refuse. It counts characters against a form's budget; it does not SEE the demo, so it passes on a card that is unreadable over the product behind it. For that, publish and call rendemo_review_demo_frames, which returns real screenshots of each step.
rendemo_run_story_director
ChatGPTClaude re-directs the whole demo as one story: selects/orders the strongest 4-12 moments, writes copy, picks per-step layout + emphasis, chooses the look, playback and ending. Give an instruction to steer (audience, outcome, tone). BY DEFAULT IT ONLY PROPOSES — it returns the story, the rationale and the exact list of changes, and writes nothing. Show the author what it would do, and call again with apply:true only after they say yes. Applying REPLACES current story choices (copy the author wrote is preserved by the proposal normalizer where ids survive).
rendemo_save_brand_style_default
ChatGPTSaves THIS project's current plan.videoStyle overrides as the workspace-wide default on-brand kinetic-text style. Future projects in this workspace inherit it automatically when their plan is first built (as long as they don't already carry their own overrides); existing projects can pick it up with rendemo_apply_brand_style_default. Use rendemo_get_brand_style_default to see what's currently saved, or rendemo_design_brand_style with saveAsDefault:true to design and save in one step.
rendemo_seed_data
ChatGPTReplace the real data in a region with plausible fake data, by pointing a TYPE at a path from rendemo_find_real_data. COPY THAT PATH EXACTLY -- they are long, and a rule whose path does not match a region replaces nothing at all; publishing now warns when a rule matches nothing, but a mistyped path is silent until then. Rules bind to a REGION (a structural path), not to the literal strings -- more durable than a find/replace list, but NOT immune to a re-record: a reordered wrapper or a renamed class can move the region the path names, and unlike a tour marker there is no automatic remap for a seed rule. After a re-record, call rendemo_find_real_data again to confirm each rule's path still covers what it used to -- a drifted path simply reappears as a fresh uncovered cluster, but only if you check for it. The same real value always becomes the same persona, so one person reads consistently across every step. Pass enabled:false to say 'that region is product copy, leave it' -- which also silences the publish advisory for it, instead of it being re-proposed on every sweep. type is usually whatever rendemo_find_real_data reported at that path, but a rule set BY HAND works with no matching finding at all: a rule replaces every text value at the path it names, whether or not a detector reported anything there. type:"company" needs this -- there is no detector for an employer name, so a column of company names never surfaces as a cluster on its own, and an author who can see one (a CRM's 'Company' column, an account list) should seed it anyway. The flip side: a path that also holds product copy has that copy replaced too, so name the cell, not its container. Add/update rules with rules (matched and replaced by label, so calling again with the same label updates it rather than duplicating it); delete rules with remove (labels). Republish to ship the change -- an already-built artifact keeps whatever it was baked with.
rendemo_set_bgm
ChatGPTControl the background-music bed under the film. enabled toggles it; mood is a text query the worker uses to retrieve a fitting catalog track when none is uploaded (e.g. 'soft minimal tech corporate', 'upbeat energetic', 'calm ambient'); volume 0..1 is the bed level under the narration (default 0.12 — keep it low so voice/UI stay legible). An uploaded track always wins over mood.
rendemo_set_cinematic_editorial
ChatGPTArrange genuine recorded source windows into branded split, full-stage, paired-output and closing scenes. Source seconds refer to the trimmed original recording. This explicitly selects a linear original-video master, clears video speed sections, and disables source click/whoosh audio because windows can be reordered. Interactive steps and framing are preserved. Paired views require a provenance note explaining the two real windows. Voiceover start seconds refer to this finished editorial timeline.
rendemo_set_demo_backdrop
ChatGPTSet the stage the demo sits on: the backdrop behind the product (one of eight curated presets — midnight, slate, graphite, linen, sand, aurora, ocean, plum — or your own solid colour or two-stop gradient), how the product is mounted on it (pad, radius, shadow) and whether a browser window frame is drawn around the recording. Pass exactly one of preset/solid/gradient, or clearBackground to go back to the plain brand-kit surface. Chrome light/dark is derived from the backdrop's own luminance unless you set mode.
rendemo_set_demo_pointer
ChatGPTConfigure the pointer and click animation in an interactive demo. cursor draws the recorded pointer between steps or hides it. clickCue controls whether the pointer moves onto each action step's target and presses it before advancing. effect selects the click animation shared with rendered video: press (a ring contracts and brightens), ring (a ring expands), burst (dots move outward), glow (the target glows with a ring), highlight (the target fills briefly), or none. tone selects a dark or light pointer for contrast with the product. scale sizes the pointer and ring together. Saves the selected settings to the project plan.
rendemo_set_demo_presentation_theme
ChatGPTSets the DEMO-WIDE scene every step starts from, plus how the accent is used and how far the camera commits. The scene here is a floor, not a lock: any step can override any axis. Five fields replace what were nine — a material is a grade, density and motion intensity were the scene's two scalars, and both connector flags were a tie.
rendemo_set_demo_spec
ChatGPTTurn on and fill the demo's Spec panel — the PRD that rides INSIDE a prototype demo, for product managers showing a feature to stakeholders and engineers. The panel has a 'This step' view (that step's notes, acceptance criteria, open question, API calls, links — set per step with rendemo_update_step / rendemo_style_steps spec) and a 'Full spec' view (this overview, then every step's spec with a jump to the moment). API calls the extension recorded on each step show automatically unless observedApi is false. comments lets reviewers leave feedback pinned to a step. A PATCH: only fields passed change; null clears a field. Republish for viewers to see it.
rendemo_set_end_card
ChatGPTSet the full-frame outro card the film ends on — the call to action (e.g. 'Start free', 'Book a demo'). Short headline; optional subtitle (a URL or tagline); and href, where the button actually SENDS a convinced viewer. Without an href the demo ends on Replay and the publish gate says so, so set it whenever the card is a real call to action. Only passed fields change; remove:true drops it. Renders on the worker (live today).
rendemo_set_product_data
ChatGPTRead and write the demo's product variables (plan.personalizationTokens) — find→replace pairs applied to the card copy AND to the replayed product's own text nodes (reassembled across element boundaries, so a name split over two spans still matches), plus image/logo swaps on the replayed imagery. This is how one recording becomes a demo that says the prospect's company name and shows their logo. Call with no ops to read the current list. set upserts by label, remove deletes by label, replaceAll:true makes set the entire list. Image/logo replacements must be an https: URL or a same-origin path.
rendemo_set_redaction_kinds
ChatGPTChoose which kinds of PII the redaction pass removes from this project's replica and its published artifact. Default (no call needed): email, phone, creditCard, ssn, moneyName, secret and handle. The one worth deciding is personName: it catches a bare Titlecase name -- the account holder's name in a sidebar, which every other detector misses -- but it matches ANY two Titlecase words, so on a product with lots of Titlecase UI copy it also flags nav labels, button text and feature names. Turn it on when a capture shows real people's names, then re-crawl and read the review. Takes effect on the NEXT build: a replica already extracted was scrubbed with whatever was set at the time.
rendemo_set_section_transition
ChatGPTSet the transition played at each chapter (establishing/wide shot): 'wipe' (an accent band sweeps across — the tasteful default), 'push' (a bolder accent sweep), 'fade' (a quick dip to accent), or 'none'. Renders in the video and the preview.
rendemo_set_step_presentation
ChatGPTSets one step's SCENE — its card, what the surround does, how the target is marked, what points at it, and whether the product itself moves — plus the copy. Copy that overflows the form it is set in is rejected before the plan is saved. For anything the scene axes cannot express, write the card yourself with rendemo_apply_custom_design.
rendemo_set_title_card
ChatGPTSet the full-frame intro card the film opens on (a themed backdrop + headline over the brand accent). Keep the headline short — a title, not a sentence (the product/feature name). Only passed fields change; pass remove:true to drop the title card. Cards render on the worker (already live for intro/end). The SAME card can open the interactive demo as a standalone welcome cover: pass showInDemo:true (plan.demoCover) and, optionally, buttonLabel for its start action.
rendemo_set_video_captions
ChatGPTBurned captions on the video, auto-transcribed from the narration (the TEXT comes from the voiceover — this controls whether they show and how they look). enabled on/off; style subtitle (clean line) or pill (rounded chip); size; position top/bottom; karaoke word-highlight. Only passed fields change. One idea per moment — keep them on the payoff, not every shot.
rendemo_set_video_shot
ChatGPTPer-shot video edit — the same operation as the editor's Shot tab: zoom (1 = full frame, up to 4x), center (pan the framing to a content-% point at the current zoom — the same math as the editor's reframe drag), holdFrom/holdTo (retime the shot's hold window, seconds), and enabled (false cuts the shot from the video; the interactive demo is unaffected). Use rendemo_get_video_plan first for shot ids and current values.
rendemo_set_video_speed_section
ChatGPTAdd a rate-override window to the video cut — RAW footage seconds (add plan.trim.start to convert from the trimmed/output timeline). speed >= 50 EXCISES the range (a hard cut, like deleting dead time); speed < 1 is slow-mo (e.g. 0.5 = half speed); speed > 1 (and < 50) speeds the range up (e.g. 4 = 4x). Sections stack — adds a new entry to plan.sections, it does not replace existing ones. Use rendemo_get_video_plan's settings.sections for current values, rendemo_clear_video_sections to remove one.
rendemo_set_video_style
ChatGPTSet on-brand kinetic-text style fields for auto section titles/feature callouts/cards — type (font/case/tracking), color (accent role/ink/scrim), motion (preset/duration/ease/stagger/direction/mask), layout (text position/card look), and per-kind variants (sectionTitle/featureCallout/stat). Deep-merges per nested field — only the fields you pass change; siblings you leave out are preserved. Use rendemo_get_video_style first to see current values, or rendemo_apply_motion_preset for a quick motion-only change.
rendemo_split_video_shot
ChatGPTBreak one shot's hold window into two independent shots at a point in time — the same operation as dragging a split on the timeline. Both halves keep the original shot's framing/annotations until you adjust them separately. Fails if the split point would leave either side shorter than 0.3s.
rendemo_start_browser_crawl
ChatGPTCapture signed-in, click-gated or robots-disallowed pages into a sandbox — the cases the headless rendemo_crawl_site cannot reach. FIRST CHECK WHETHER A RECORDING IS POSSIBLE: if the user can walk through the product themselves, the Rendemo Chrome extension's 'Record this tab' (then 'Stop' and 'Send to Rendemo') captures real interaction and real data rather than the page-at-a-time snapshots this tool collects, and queues auto-direction on upload — see the new-demo skill. Use this when a recording is not on the table but the pages need a login. CALL THIS EVEN IF YOU HAVE NO BROWSER CONTROL: lacking browser tools does NOT make this impossible, and no cloud/hosted browser is needed or usable. Two ways the pages get captured, both through this same tool: 1. NO BROWSER TOOLS (ChatGPT and most clients): call this, then give the USER the capture code from the result. They paste it into the Rendemo Chrome extension's 'Capture pages for a sandbox' popup mode, signed in on the site — and from that moment YOU capture the pages: rendemo_capture_pages({ crawlId, url, urls }) opens each url in their signed-in tab and captures it, no clicking on their side. When the sandbox has what it needs, call rendemo_finish_browser_crawl. 2. YOU DRIVE A BROWSER THE AUTHOR IS ALREADY SIGNED INTO — their real, local browser with their sessions. A CLOUD OR HOSTED BROWSER YOU OPENED YOURSELF DOES NOT QUALIFY: it holds none of the author's sessions and providers like Google refuse sign-ins from automated browsers, so never ask the author to log in inside one — use path 1 instead. Per page: navigate, WAIT for it to finish rendering (the recorder snapshots the instant it arms; armed too early, the page is captured as an empty shell and discarded as a duplicate), then evaluate snippet with that page's index. The page uploads itself and returns a receipt; finish when every page posted. No credential ever reaches Rendemo on either path. Returns a crawl id, a short-lived ingest token, the capture code, and the snippet. IF THIS CRAWL WILL BECOME A SANDBOX DEMO, read the sandbox-demos skill (rendemo_load_craft_skill) while you go.
rendemo_start_drive_session
ChatGPTOpen a session in which YOU drive the user's product tab, signed in only when needed. It starts in REHEARSAL: nothing is recorded while you use rendemo_drive_read, rendemo_drive_navigate, rendemo_drive_click, rendemo_drive_type, rendemo_drive_scroll, and rendemo_drive_wait to rehearse until you know the way to the outcome. Then rendemo_propose_drive_plan writes the take as a numbered plan the user approves in chat, and rendemo_record_drive_plan records exactly that plan in one clean pass after they click 'Record the plan'. The result is a REAL take (real clicks, typing, transitions) that auto-directs into a recorded demo. Returns a session id and a code; give the user the paste steps verbatim.
rendemo_style_player_shell
ChatGPTRestyle the demo player's own chrome -- the header, the transport bar, the step dots, the chapter list and the footer -- with your own CSS. Every selector must name a piece of the chrome: any .rps-* class, .modebtn, or .wrap / .col on their own. Selectors are scoped and specificity-raised for you, so write plain rules and no !important. Pass clear:true to go back to the stock chrome. Read the class names off rendemo_get_embed, or ask for the current sheet with css omitted.
rendemo_style_steps
ChatGPTBulk-update step copy, emphasis, markers, choreography, travel pacing and framing (playIn/playSpeed/holdThrough) and real-DOM effects — the whole per-step patch surface, up to 40 steps in one call. Use rendemo_apply_presentation_direction for recipe assignments and rendemo_auto_direct for camera framing.
rendemo_suggest_step_presentations
ChatGPTProposes a FORM per step from its role, the director's story intent, its narrative position, and whether it has a target to point at — resolving through the same intent map the build uses, so a suggestion cannot disagree with what publishing would produce. The result can be passed to rendemo_apply_presentation_direction as-is. Reads the plan; changes nothing.
rendemo_synthesize_narration
ChatGPTGenerate real local Kokoro speech and attach it to this recorded project for the next normal film render, including estimated word timings for captions. This is separate from generate_narration, which writes story copy. Pass the saved plan version and exact script lines. For a normal cut, beatId references an enabled beat and startSeconds overrides its anchor on the film BODY output timeline, excluding inserted cards. For a cinematicEditorial plan, beatId references an editorial scene ID and startSeconds is required on the FINISHED output timeline, with no card offset. Speech must fit without overlap: the job fails instead of silently shifting, clipping, or dropping authored lines. Poll get_narration_status before rendering; changing the capture or plan during synthesis refuses attachment.
rendemo_take_demo_offline
ChatGPTStop serving ONE published demo or tour, without deleting anything. Its public link, its poster, and any tour running on the customer's pages all go dark within 30 seconds (the payload's edge-cache window); a visitor whose tour is ALREADY running finishes it — this stops it being served, it does not reach into open tabs. The published plan is preserved, so re-publishing later serves the identical artifact. Use this the moment a live tour is wrong, points at removed UI, or should not be running. To take EVERY tour in the workspace down at once (a release that moved the UI out from under all of them), the human turns off Settings → Product tours instead. To put this one back on the air, publish it again (rendemo_publish_demo) or use Put back online in the library.
rendemo_trim_video
ChatGPTSet the video's start/end trim — RAW footage seconds (the same clock plan.sections use), not the trimmed/output timeline. Cuts everything before the start point and after the end point. Only passed fields change (start or end alone shifts just that edge); the other edge is clamped so start stays before end. Use rendemo_get_video_plan's settings.trim for current values.
rendemo_tune_video
ChatGPTPlan-level video feel: pacing (tight time-warp with a max speed, or off for real time), click effects (style/intensity/zoom-punch, plus motionBlur — physically-correct camera motion blur on fast moves, final renders only), cursor styling (trail: 'comet' is the signature accent-glow ribbon that lights up on ordinary mouse travel; 'subtle'/'strong' only fire on fast flicks; 'off' disables), and the sound mix (clicks, whoosh, background music level, narration cleanup). Only passed fields change.
rendemo_unpublish_sandbox
ChatGPTTake a SANDBOX back off the air: its public URL stops serving and the replica becomes visible only to members of the workspace that owns it. Idempotent — running it on a sandbox that is already a draft simply confirms that. Safe by construction (it can only ever expose less, never more), so it needs no redaction re-check. Frees the published-artifact slot the sandbox was holding. Sandbox demos authored from this source remain editable, but their published viewer cannot run until the source sandbox is live again.
rendemo_unpublish_tour
ChatGPTUnpublish one codebase tour, stopping public serving within the 30-second edge-cache window. Returns the source markers to remove and the updated rendemo.tours.json contents, preserving other tours. The caller must apply those returned source and lockfile edits in the same change. Stored draft and published plans are retained for later republishing. To temporarily stop serving without source cleanup, use rendemo_take_demo_offline.
rendemo_update_step
ChatGPTTargeted patch on one step (recorded beat or authored step): title, blurb, CTA label, the step SCENE (form, grade, entrance, mark, tie, reveal, scale, weight) + emphasis color, click marker, card variant/size/placement/anim, eyebrow, per-step choreography, narration, branch choices, persona variants, hidden, and effects — the real-DOM treatments the interactive embed applies to the replayed element itself (pop/lift/tilt/nudge/tint/type/set-text/toggle-class/spotlight/count-up/progress/reveal/hide). Only the fields you pass change. Pass null on a nullable field to clear it.
rendemo_watch_captures
ChatGPTWAIT for the user to finish recording their product with the Rendemo extension, then report the project it became and whether the story director has finished with it. Call this immediately after telling someone to record — it HOLDS THE CONNECTION OPEN (up to 120s per call, 60 by default) and returns the moment something lands, so you do not need the user to tell you they are done and must not ask them to. IF IT RETURNS NOTHING YET, CALL IT AGAIN IMMEDIATELY with the sinceIso it gives back: that is not a stopping point and not something to report to the user. Ending your turn there strands them — a chat has no timer, so nothing resumes the wait, and the recording they just made is never picked up. It watches for HUMAN recordings only (browser extension and desktop recorder); seeded sample projects and crawl-built projects are excluded, so a crawl you started yourself will not end the watch — poll that with rendemo_get_crawl_status. Pass projectId to wait on the direction of a recording that has already arrived. Pass crawlId instead to watch a CAPTURE-CODE session from rendemo_start_browser_crawl: it reports how many pages have really reached storage, which is how you catch a code that was never pasted on page one instead of discovering at finish that nothing arrived. Read the new-demo skill for what to do with it once it does.
rendemo_write_step_captions
ChatGPTRewrite step titles + helper lines with Claude from the recorded click-through (the same writer behind the editor's AI improve). mode 'fill' captions only element-labeled steps; 'rewrite' redoes every step. Author edits always survive 'fill'.
