Rendemo

One 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_apply_video_treatment

Copies 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_step_presentation_style_to_all

Applies an approved recipe sequence while preserving copy, interactions, branches, narration, hotspots, and analytics identifiers.

rendemo_apply_presentation_direction

Merges 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_brand_style_default

From 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_author_sandbox_demo

Asks 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_brand_style

One 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_auto_direct

Capture 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_capture_pages

Fetches 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_probe_tour_targets

For 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_check_sandbox_demo

The 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_configure_lead_capture

Crawl 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_crawl_site

Create 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_tour

Create 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_sandbox_demo

A 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_create_tracking_link

HARD-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_delete_video_shot

Writes 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_design_card

Set 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_direct_step

Close 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.

rendemo_finish_drive_session

A time-limited download link for the published demo as one self-contained offline HTML file (replay, styling, interactions and media embedded). Publish first.

rendemo_export_offline

Read-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_find_real_data

Close 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_browser_crawl

Frame 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_frame_video_shot

A 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_tour_preview

Status 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_crawl_status

The 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_demo_analytics

The 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_journey

The 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_plan

Status of queued/running renders — pass a renderId, or omit it for the workspace's recent renders.

rendemo_get_render_status

Read 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_get_video_style

Everything 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_embed

The 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 [email protected] 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_lockfile

Read 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_brand_style_default

Zero-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_director_lint

Every 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_revisions

Every 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_sandbox_pages

Captured 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_leads

Returns 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_presentation_recipes

Every 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_remove_tour to retire the whole thing.

rendemo_list_tours

List 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_projects