VideoZero

Create a new, empty VideoZero project to author scene code in yourself. It is created immediately with status "new" and an empty scene; write the scene with scene_update_build. Set the title and aspect ratio here. Call get_started first for usage instructions if you have not already in this conversation. (To have VideoZero's managed pipeline write a complete video from a prompt instead, use video_generate — then project_clone its result if you want to hand-edit it here.)

Permanently delete a project you created with these tools, including its scenes and asset bindings. This cannot be undone. Only projects with source "agentic_mcp" can be deleted here; uploaded media files stay in your library (clones may still reference them).

Edit a project's metadata (title and/or aspect ratio). Changing the aspect ratio re-derives the render resolution and un-validates every stored scene (they were validated at the old resolution) — rebuild each with scene_update_build or scene_patch_build afterwards.

Get full metadata for a project you own: title, status, source, aspect ratio, version, build/validation state, public flag, view URL, and a per-scene overview (index, title, validated, narration count) — the structure without the code.

List your VideoZero projects (all sources). Returns id, title, status, source, aspect ratio, version, and build/validation state. Only projects with source "agentic_mcp" are directly editable — clone any other with project_clone first. Pass `source` to filter.

List the named assets bound to a project (ready to use via `asset('<name>')`) plus any pending uploads that have not been completed yet. Use this to check whether a requested upload has landed.

Get the shareable browser URL to view a project. Returns the URL as text; use project_view to embed the live player widget instead.

Open a project in the inline VideoZero player so the user can watch it and export it. Renders a live player widget and keeps it in sync as you edit — when you publish a new scene version the player reloads automatically.

Delete the scene at `index` from a project. Scenes after it shift down by one (their indices change). The project version bumps and the player refreshes.

Inspect the live scene graph of a validated scene at a specific frame, returned as JSON. The scene is built and seeked to `frame` (default 0), then its node tree is serialized: for each node its type, key, local position/size/opacity/fill/text, and its on-screen (absolute) position and world-space bounding box. Use this to debug layout — find nodes rendered off-screen, with zero size, fully transparent, or overlapping — without eyeballing pixels. Complements scene_view_frames (which shows the image). Only projects created by these tools are inspectable; clone others first.

Apply search/replace patches to the current (last validated) scene code, then build and validate. Prefer this over scene_update_build for incremental edits. Each patch replaces old_string with new_string; old_string must be unique unless replace_all is true — include enough surrounding context. The result is persisted ONLY if it builds and validates; otherwise the previous validated scene is kept and the patched code is returned for inspection. On a clean patch+validate the version bumps and the player refreshes. Narration, music and sound effects live in the scene code and are re-resolved on every successful build. Only projects created by these tools are editable — for any other project, create an editable copy with project_clone first.

Read the current (last validated) scene code for a project. Pass line_start/line_end to read only a slice of a large scene (use scene_search_code to locate the lines first).

Reorder a project's scenes. Pass `order` as a permutation of every current index — e.g. [2, 0, 1] makes the current scene 2 play first. Scene indices follow the new order afterwards; the project version bumps and the player refreshes.

Search a project's scene code for a regex pattern and return matching lines with surrounding context. Much cheaper than scene_read for finding specific identifiers, imports, or call sites. Each match includes a 1-indexed line number and `context` lines of surrounding code. If the regex does not compile, falls back to a literal substring search automatically. Examples: `"^import"` lists imports; `"root\.add"` finds all `root.add(...)` calls.

Write a scene as complete TypeScript Motion Canvas code, then build and validate. Replaces the scene at `index` (default 0) entirely; write to the next unused index to append a scene to the project. The code is persisted ONLY if it both compiles and validates — so the stored scene is always a working build. On success the project version bumps and the player refreshes. On failure the previous validated scene is kept; fix the reported errors and call again (or use scene_patch_build for incremental edits). Voiceover narration, music and sound effects are declared inside the scene code itself and resolved automatically during the build — see the skills docs via skills_list for the audio APIs. Only projects created by these tools are editable — for any other project, create an editable copy with project_clone first.

Render several frames of a validated scene tiled into a single "contact sheet" PNG, each captioned with its frame number and timestamp — a fast way to eyeball timing and motion across the whole scene in one image. Pass `frames` as an explicit list or leave it "auto" (default) to sample frames evenly from first to last. The scene is validated once and all frames are drawn from that build.

Render one or more frames of a project's validated scene as PNG images so you (or the user) can see what it looks like. Provide a list of frame numbers (defaults to [0]; each clamped to the valid range; at most 8 per call). The scene is validated once and every requested frame is rendered from the same build.

List the available skills (authoring guides) and their reference docs, or search across them. Consult the relevant guides BEFORE writing scene code. Without `query` it returns a table of contents: each skill with its description and the relative paths of its SKILL.md and reference docs. With `query` it searches every doc and returns the matching docs with the matching lines. Read any listed path with skills_read.

Read a single skill document by its path relative to the skills directory (e.g. "motion-canvas/SKILL.md" or "motion-canvas/references/TXT.md"). Use skills_list to discover paths.

Search royalty-free stock media across the available providers. Use when a scene needs a realistic asset that cannot be drawn with shapes or icons. Pass `type` to choose the kind of media (defaults to photo). Returns descriptive results — pick one and pass its `provider`, `type` and `id` to stock_use to add it to the project. You do not get media URLs; assets are referenced by name once added.

Add a result picked from stock_search to a project as a named asset. Pass the result's `provider`, `type` and `id` plus a `name`; it is materialised server-side and bound to the project. Reference it in scene code with `import {asset} from 'vzrt';` then `asset('<name>')` (for an image, `<Img src={asset('<name>')} />`) — attribution is handled automatically and no URL is exposed.

List the scene templates available as starting points. Pass `keywords` to search by concept. Read a template with template_read.

Read a single scene template by name (e.g. "default"). Returns the complete template scene code. Use template_list to discover available templates.

Render a template's scene into a "contact sheet" PNG — several frames tiled into one image, each captioned with its frame number and timestamp — to eyeball how a template looks and moves before starting from it. Pass `aspect_ratio` to render at a given shape (defaults to 16:9), and `frames` as an explicit list or "auto" (default) to sample evenly across the scene. Use template_list to discover template names.

Check your VideoZero plan and remaining usage. Reports the video-generation credit pool (consumed by video_generate/video_revise) and the daily/monthly standing of each metered project/scene action. Read-only — calling this consumes nothing. Use it before large jobs or when a tool reports a limit error.

Generate 2D motion graphics, animations and narrated explainer videos from a structured prompt. VideoZero creates lightweight HTML-canvas-based videos using shapes, SVG, text, charts, LaTeX formulas and diagrams, and supports exporting the result to MP4. It does not generate photorealistic, cinematic, live-action, landscape, people/faces, or true 3D video. Routing rule: - Use this tool only when the requested output can be represented as 2D motion graphics: shapes, text, charts, diagrams, formulas, UI-style animations, or simple illustrative scenes. - Do NOT use this tool when the user asks for photorealistic, realistic, cinematic, live-action, natural landscape, human/face, camera-footage, real-world scene, or true 3D rendering. - Do NOT "reinterpret" an unsupported request as a stylized 2D version unless the user explicitly asks for that fallback. - If the request is unsupported, explain the limitation and offer a 2D motion-graphic alternative without invoking the tool. - If the user wants to change, iterate on, or refine an EXISTING VideoZero project, use video_revise instead. Good uses (2D motion graphics built from simple elements): - Kinetic typography, titles, captions/subtitles — e.g. "Create a kinetic typography intro." - Diagrams, charts, plotted graphs as animation (not a single still) — e.g. "Animate a bar chart race." / "Show a 2D solar-system diagram with labels." - Math / LaTeX formulas rendered on-screen — e.g. "Make a video explaining Bayes' theorem with formulas." - Algorithm & data-structure visualizations (arrays, pointers, partitions, swaps, recursion, etc.) — e.g. "Animate Dijkstra's algorithm on a graph." - 2D physics / systems illustrations (mass-spring, vectors, matrices) using shapes/arrows/labels. - Educational or explanatory 2D animations / videos. Bad uses: - "Generate a photorealistic mountain range." - "Make a cinematic drone shot over mountains." - "Create realistic footage of a city street." - "Animate a real human presenter." - "Render a 3D product shot with realistic lighting." Behavior: - Generate a NEW video based on the structured prompt from scratch or based on referenced VideoZero scenes. - Returns immediately with a prompt_id (also the project_id); rendering happens asynchronously and the UI polls status and informs once the video is ready. - To build on existing public VideoZero scenes as inspiration for a NEW video, include their scene IDs in the referenced_scenes field. This is distinct from revising a project the user already owns — for that, use video_revise. - The default resolution is 1920x1080 (Full HD) at 60 FPS. Other aspect ratios are supported: 16:9 (1920x1080), 9:16 (1080x1920), 1:1 (1440x1440), 4:3 (1600x1200), 4:5 (1280x1600), 3:4 (1200x1600), 2:1 (2160x1080), 1:2 (1080x2160). Input structure: - Provide a structured prompt with title, meta (audience, objectives, description, keywords), style (appearance, colors, components), and ordered scenes with beats. - Each scene has beats with marker_id, visuals, audio (voiceover text), and actions. - Specify visual style via the style object: appearance (light/dark), colors map, and component descriptions. - If including math, provide LaTeX in beat visuals. - If including algorithms, describe each step to animate in beat actions. - Voiceover/Narration goes in beat audio fields. Do NOT use this tool for: - revising, editing, or iterating on an existing VideoZero project (use video_revise instead) - standalone/static images (use an image tool instead) - photorealistic content or real-world video synthesis (faces/people, landscapes, “realistic” scenes) - 3D models or 3D scenes (teapots, 3D renders, realistic lighting, raytracing) - editing/trimming/modifying an existing non-VideoZero video file - generating or editing audio only - downloading, converting, transcoding, playing, or streaming video files Related: this tool returns a project_id. To hand-edit the generated result scene-by-scene with the project_*/scene_* tools, first create an editable copy with project_clone.

Use this when the user wants to like or favorite a VideoZero video project. Do not use for general bookmarking or saving unrelated content.

Prompt a revision for an EXISTING VideoZero video project. The revision inherits the parent's structured prompt and applies natural-language revision instructions on top. Use this when the user wants to iterate on a project they've already created — e.g., "make the background darker", "replace scene 2 with something about gradients", "shorten the outro", "add a recap at the end". If needed, change the aspect ratio with new_aspect_ratio (leave blank to reuse existing). Do NOT use this to create a new video from scratch; use video_generate for that. Behavior: - Requires the parent project to already have a structured prompt. - Accumulates the new instructions onto any prior revision instructions for the same project. - May attach additional files (e.g. to swap a logo or add a reference photo) — they're added to the asset pool inherited from the parent project. - Returns immediately with a new prompt_id (also the revised project_id); rendering happens asynchronously and the UI polls for status.

Use this when the user wants to unlike or remove a VideoZero video project from their favorites. Do not use for deleting projects or removing content.