asset_request_upload
ChatGPTRequest an ephemeral upload URL to add an image or video asset to a project — including media you generated yourself for a beat that needs specific imagery. You cannot send file bytes through this tool — it returns a short-lived, single-use URL to POST the file to (multipart/form-data, field file): POST it yourself if you hold the bytes, otherwise hand the URL to the user. Alpha is preserved, so upload transparent PNG/WebP/SVG (or WebM video) for anything that must composite over the scene. Once uploaded, reference the asset in scene code with import {asset} from 'vzrt'; then asset('<asset_name>') (e.g. <Img src={asset('<asset_name>')} />). Poll project_list_assets to see when it has landed.
asset_snapshot_page
ChatGPTSnapshot a public web page into a project asset the Html component renders: the page is opened in a browser, its scripts settle, and the DOM is captured with styles, images and fonts embedded (scripts removed). Use it to put a real website, landing page or web app screen into a video — then animate it like any Html node: import {asset} from 'vzrt'; import {Html, crossfadeHtml} from 'vzc/Html'; and <Html src={asset('<name>')} size={view.size()} /> (hover(), toggleClass(), run(), vars, a Cursor, zooming/panning via the node's scale/position all work on the snapshot). Pages behind logins or heavy on video cannot be captured; very image-heavy pages may exceed the size limit.
asset_upload
ChatGPTAdd asset(s) to a project from file(s) the user attached to their message (delivered inline by the host; you do not send bytes yourself). Use file_descriptions to name each asset; after upload reference it in scene code with import {asset} from 'vzrt'; then asset('<name>').
component_docs
ChatGPTRead a component's docs by its id (e.g. "ProgressRing"), optionally pinned with @version. The docs cover the component's options, kinds and animation API. Pass search to return only matching doc lines instead of the full markdown. Use component_search to discover ids.
component_example_scene
ChatGPTGet a component's showcase example scene (complete, renderable TSX) by its id (e.g. "ProgressRing"), optionally pinned with @version. The example demonstrates how to import and animate the component — a good starting point to copy from. Use component_search to discover ids.
component_search
ChatGPTSearch the vzc component library (reusable scene components). Pass query to match by name, description, keywords, kinds, type or docs; omit it to list the whole catalog. Each result includes the component id, a spec for vzc/Name@version imports, its kinds and a short description. Read full docs with component_docs and see a worked example with component_example_scene.
component_view_contact_sheet
ChatGPTRender a component's showcase example scene into a "contact sheet" PNG — several frames tiled into one image, each captioned with its frame number and timestamp — to see how a component looks and animates before using it. Identify the component by its id (e.g. "StatusCard"), optionally pinned with @version (e.g. "StatusCard@0.1.0"; omit or use @latest for the newest). 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 component_search to discover ids.
feedback_submit
ChatGPTReport a gap or issue you hit while authoring: a missing template or component, a hole in the docs, a tool you wished existed, a bug, or a lesson worth recording. This is fire-and-forget — the feedback is filed for the VideoZero team and only its receipt is acknowledged; nothing about the current project changes. Attach whatever situational detail is relevant via context.
get_started
ChatGPTStart here: returns up-to-date VideoZero instructions plus account-specific state — the user's plan, remaining usage, and their most recent projects. Call this once at the start of a conversation before other VideoZero tools; call it again any time you need a refresher.
list_icons
ChatGPTSearch icons across all collections. Pass every icon you need at once in queries; results are grouped per concept and ranked, so you do not need to search a concept again or filter by collection. Reference a result in scene code as its collection:name string (e.g. <Icon icon="mdi:lion" />).
project_clone
ChatGPTClone one of your own projects into a new project. A full copy: every scene (with narration/audio), asset bindings and aspect ratio carry over; the clone starts private at version 0. Use this when the user wants to keep the original and work on a copy; any project can also be edited directly. Call get_started first for usage instructions if you have not already in this conversation.
project_create
ChatGPTCreate 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 — once its run has finished you can hand-edit that project here.)
project_delete
ChatGPTPermanently 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 (delete others on videozero.ai); uploaded media files stay in your library (clones may still reference them).
project_edit
ChatGPTEdit 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.
project_get
ChatGPTGet 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.
project_list
ChatGPTList your VideoZero projects (all sources). Returns id, title, status, source, aspect ratio, version, and build/validation state. Every listed project can be edited directly with the scene_* tools. Pass source to filter.
project_list_assets
ChatGPTList 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.
project_video_url
ChatGPTGet the shareable browser URL to view a project. Returns the URL as text; use project_view to embed the live player widget instead.
project_view
ChatGPTOpen 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.
scene_delete
ChatGPTDelete 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.
scene_inspect_graph
ChatGPTInspect 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).
scene_patch_build
ChatGPTApply 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.
scene_read
ChatGPTRead 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).
scene_reorder
ChatGPTReorder 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.
scene_search_code
ChatGPTSearch 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.
scene_update_build
ChatGPTWrite 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.
scene_view_contact_sheet
ChatGPTRender 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.
scene_view_frames
ChatGPTRender 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.
skills_list
ChatGPTList 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.
skills_read
ChatGPTRead 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.
stock_search
ChatGPTSearch 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.
stock_use
ChatGPTAdd 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.
template_list
ChatGPTList the scene templates available as starting points. Pass keywords to search by concept. Read a template with template_read.
template_read
ChatGPTRead a single scene template by name (e.g. "default"). Returns the complete template scene code. Use template_list to discover available templates.
template_view_contact_sheet
ChatGPTRender 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.
usage_get
ChatGPTCheck 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.
video_generate
ChatGPTCreates a NEW mostly-2D animated video / motion-graphic using VideoZero. This tool produces a lightweight HTMLCanvas-based animation (2D shapes/text/plots) and supports exporting the result to MP4. Use this when the user wants a 2D animation/video built from simple elements, such as: - kinetic typography, titles, captions/subtitles - diagrams, charts, plotted graphs (as animation, not a single still) - math / LaTeX formulas rendered on-screen - algorithm & data-structure visualizations (arrays, pointers, partitions, swaps, recursion, etc.) - 2D physics / systems illustrations (mass-spring, vectors, matrices) using shapes/arrows/labels - Educational or explanatory 2D animations / videos Routing rule: - If the request requires photorealism, human faces/people, real-world landscape realism, or true 3D rendering, do NOT use this tool. - If the user wants to change, iterate on, or refine an EXISTING VideoZero project, use video_revise instead. 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 (1080x1080), 4:3 (1440x1080), 4:5 (1080x1350), 3:4 (1080x1440), 2:1 (2160x1080). 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
video_like
ChatGPTUse this when the user wants to like or favorite a VideoZero video project. Do not use for general bookmarking or saving unrelated content.
video_revise
ChatGPTCreate a revised version of an EXISTING VideoZero video project. The revision inherits the parent's structured prompt and aspect ratio, 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". 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. - Returns immediately with a new prompt_id (also the revised project_id); rendering happens asynchronously and the UI polls for status.
video_unlike
ChatGPTUse 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.
