clipchat_add_comment
ChatGPTAdd a comment to the session's timeline. Requires the ClipChat desktop app running and signed in as the same account.
Overview
Runchat is a node-based canvas for design workflows used by architects, designers and computational designers. Connect your Runchat account to build, edit and run workflows from ChatGPT: chain language models, design-visualisation models and code into a reusable pipeline, then publish it as a tool or a hosted page. With the Runchat plugin running in Rhino, Grasshopper or Blender, ChatGPT can also read your open model, run scripts in it, build Grasshopper definitions and capture the viewport to check its work. With the ClipChat desktop app, it can edit your screen recordings into finished videos. Requires a Runchat account. Desktop tools only work while the matching Runchat plugin or ClipChat app is open and signed in to the same account.
Tools
clipchat_cursor_at
ChatGPTReport where the mouse pointer was at a moment of the recording and the area it covered around it. Read-only. Requires the ClipChat desktop app running and signed in as the same account.
clipchat_delete_edit
ChatGPTRemove one edit from the plan and delete its rendered video. To change an edit, use write_plan instead. Requires the ClipChat desktop app running and signed in as the same account.
clipchat_edit_transcript
ChatGPTReplace text in the session's transcript in place, keeping timings. Overwrites the transcript text that subtitles are built from. Requires the ClipChat desktop app running and signed in as the same account.
clipchat_get_clip
ChatGPTExtract a short window (at most 20s, with audio) of the recording or an imported asset and attach it to your next turn. Read-only. Requires the ClipChat desktop app running and signed in as the same account.
clipchat_get_speech
ChatGPTRead back exactly what the viewer will hear in each span: every transcript word with per-word times at the edges, plus the words just outside each edge. Read-only. Requires the ClipChat desktop app running and signed in as the same account.
clipchat_grab_frame
ChatGPTExtract one frame of the recording (or of a rendered output) and attach it to your next turn so you can see it. Read-only. Requires the ClipChat desktop app running and signed in as the same account.
clipchat_grab_frames
ChatGPTGrab 2-8 frames and tile them into one labelled contact sheet attached to your next turn, for judging cuts and crops. Read-only. Requires the ClipChat desktop app running and signed in as the same account.
clipchat_import_media
ChatGPTCopy media files or URLs into the session's assets. With no session_dir and no media-only session active, creates a new media-only session. Requires the ClipChat desktop app running and signed in as the same account.
clipchat_label
ChatGPTProduce the session's scene labels if they don't exist yet (resumable). Requires the ClipChat desktop app running and signed in as the same account.
clipchat_label_asset
ChatGPTDownload an external video into the session's asset cache and label its scenes. Requires the ClipChat desktop app running and signed in as the same account.
clipchat_list_comments
ChatGPTRead the session's timeline comments. Read-only. Requires the ClipChat desktop app running and signed in as the same account.
clipchat_list_edits
ChatGPTList every video in the session's edit plan with its id, revision, duration and whether it needs re-rendering. Read-only. Requires the ClipChat desktop app running and signed in as the same account.
clipchat_list_sessions
ChatGPTList the user's ClipChat recordings, newest first, with which artifacts each already has (transcript, labels, plan, outputs) and which one is active. Read-only. Requires the ClipChat desktop app running and signed in as the same account.
clipchat_render
ChatGPTRender the plan's edits to video files, replacing earlier renders of the edits that changed. Returns immediately; poll clipchat_render_status. Only when the user asks for the files. Requires the ClipChat desktop app running and signed in as the same account.
clipchat_render_cancel
ChatGPTStop the render running for this session. Requires the ClipChat desktop app running and signed in as the same account.
clipchat_render_status
ChatGPTReport the progress of a running render, or its output files when done. Read-only. Requires the ClipChat desktop app running and signed in as the same account.
clipchat_seek
ChatGPTMove the open ClipChat viewer's playhead. Requires the ClipChat desktop app running and signed in as the same account.
clipchat_select_session
ChatGPTMake a recording the active session for every later ClipChat call. Requires the ClipChat desktop app running and signed in as the same account.
clipchat_start_recording
ChatGPTStart a screen recording with the app's saved capture settings and normal countdown. Requires the app to be idle. Returns {state, session_dir}. Requires the ClipChat desktop app running and signed in as the same account.
clipchat_stop_recording
ChatGPTStop and save the live recording (including a paused one) and make it the active session. Returns {state, session_dir}. Requires the ClipChat desktop app running and signed in as the same account.
clipchat_transcribe
ChatGPTProduce the session's word-timestamped transcript if it doesn't exist yet (resumable; returns the existing one otherwise). Requires the ClipChat desktop app running and signed in as the same account.
connect_nodes
ChatGPTConnect an output handle of one node to an input handle of another — one edge, or many via
edges. Give source_handle/target_handle unless the match is unambiguous; ambiguous calls return the available handles. Common handles — promptNode in: "prompt", "messages" (any type) / out: "messages", "artifacts"; codeNode in: "code" / out: "result" plus declared outputs; inputNode out: "content"; imageNode in: from get_model_params (prompt, image_url, first_frame_url…) / out: "image". Hidden parameters (instruction, format) cannot be connected. An edge overwrites the target input's whole value — never also use a {{nodeId.param}} template there.copy_runchat
ChatGPTCreate a new runchat owned by the authenticated user that starts as a duplicate of an existing runchat's canvas (nodes and edges), for adapting or remixing it. The source must be one of the user's own runchats, shared with their team, or public; the source is not changed. Returns the new runchat id and its editor URL.
create_artifact
ChatGPTCreate and publish a hosted page at runchat.com/p/{handle}/{slug}. Type is inferred: markdown → blog, HTML → website, HTML using window.runchat → app (visitors run the published workflow with their own credits). For an app: publish_runchat first, load the app-artifact skill, test the HTML in an html code node, then pass it here as raw text (never entity-escaped). Returns artifact_id and URL. Revise later with update_artifact, never a duplicate.
create_artifact_node
ChatGPTCreate an artifact node (artifactNode) that saves ('create') or fetches ('get') an artifact AS A WORKFLOW STEP — only when the workflow must regenerate the artifact each time it runs; otherwise use create_artifact / update_artifact directly. Type is inferred from content (markdown → blog, HTML → website, HTML using window.runchat → app). Author app HTML in an html code node first and connect its result into
content. use_skill "app-artifact" before building one.create_code_node
ChatGPTCreate a code node (codeNode). Load the language's skill first (use_skill) if not already loaded — it defines the sandbox contract. Code runs on the SERVER only when the node is run. Output on the 'result' handle, or on the handles declared in
outputs when the code returns an object with those keys. inputs declares named input handles, read in code as same-named variables.create_files
ChatGPTAdd files to a JavaScript or html code node: package.json for npm dependencies, modules, assets. JavaScript: extra server modules (the node upgrades to the bundler sandbox). Html: browser ES modules and stylesheets referenced from index.html via <script type="module" src="/src/main.js"> / <link rel="stylesheet">, bundled into one page at render time (import CSS via <link>, never from JS). Errors on existing paths (use edit_file); the entry file already exists.
create_image_node
ChatGPTCreate a media generation node (imageNode) — images, video, 3D, or audio. Requires a model_id: for plain text-to-image use the default "runware:400@2" with params { "prompt": "..." }; otherwise discover models with list_models and their
params keys with get_model_params. Unknown params are reported back in a warning with the model's valid params. The generated media is on the 'image' output handle, and run_nodes returns its URL. Upload local/generated images first and pass hosted URLs; never inline base64 or data URLs in node inputs.create_input_node
ChatGPTCreate a user-input widget (inputNode); its value is on the 'content' output. Pick the widget with
format; one starting value with value, a LIST with values (one node holds the whole list — never N nodes), options/selected for a select. Image values are hosted URLs, never base64/data URLs.create_note
ChatGPTCreate a markdown note node (noteNode) — documentation, findings, links, images, or checklists (
- [ ] item renders as a tickable checkbox). Never empty.create_prompt_node
ChatGPTCreate an LLM node (promptNode). Inputs: 'prompt' (the task), 'messages' (context, prior outputs, images — any type). Outputs: 'messages' (the conversation), 'artifacts' (structured output when output_format is set).
create_runchat
ChatGPTCreate a new, empty runchat owned by the authenticated user. Returns the runchat id to use with the canvas tools, plus its editor URL. Optionally place it in a folder and tag it to keep generated runchats organized. To start from an existing runchat, use copy_runchat.
delete_edges
ChatGPTDelete edges — disconnect nodes without deleting them.
delete_files
ChatGPTDelete one or more non-entry files from a JavaScript or html code node. Cannot delete the entry file.
delete_nodes
ChatGPTDelete nodes (and their edges) from the canvas.
edit_app_state
ChatGPTWrite an app's shared state directly, for apps without a command for what you need. Prefer app_command when one fits: commands keep the app's state valid. Ops apply in order in one step: set (replace a key), merge (shallow-merge an object into a key), append (add items to a list key, keeping at most max), delete, clear (every key).
edit_file
ChatGPTEdit one file in a code or note node (a note is the single file 'note.md'). Targeted edit: pass old_text (exact, unique in the file) and new_text; empty new_text deletes the span. Full overwrite: pass only new_text. read_files first. Do not also paste the file content in your reply.
fetch_page
ChatGPTFetch a webpage in a headless browser (JavaScript executed). 'markdown' (default) returns readable text with links; 'links' the outbound links; 'html' the raw markup. Long pages come in windows — pass the returned next_offset as offset to continue. For visual appearance use view_image on the URL.
get_artifact
ChatGPTFetch an artifact by id: name, entry-file content, URL, visibility and publish state (your own, or others' artifacts you may view). Read before update_artifact.
get_canvas
ChatGPTOverview of the canvas: node ids, types, labels, positions and edges, plus the runchat_id (also the published tool id) and latest published version (null if unpublished). 50 nodes per page — when has_more is true call again with next_offset. Not for verifying nodes you just created.
get_edit_context
ChatGPTPull a ClipChat recording session's edit context: the transcript (segment-level lines — word-level times come from clipchat_get_speech), scene labels from a video model (when available), measured speech runs and input boundaries (every click, and where typing/scrolling runs and untouched stretches start and stop), duration/resolution/pre-roll, rendered outputs, viewer comments, and the user's standing edit instructions. Call this FIRST when asked about the recording or an edit. Defaults to the session the app has open; pass session_dir (from clipchat_list_sessions) to target another.
get_model_params
ChatGPTGet full parameter details for one or more models. Returns parameter names, types, and defaults — use these as the
params keys of create_image_node. No runchat_id needed. Discover valid model_ids with the list_models tool. Pass model_id for one model or model_ids for several. Only call once per model.grasshopper_configure_components
ChatGPTConfigure placed components: per-parameter data mapping (flatten/graft), simplify and reverse, viewport preview, enabled state, or a one-shot bake of the component's geometry into the active Rhino document. Requires the Runchat plugin running in Rhino; Grasshopper opens automatically. Load the "grasshopper-canvas" skill first for the full API reference.
grasshopper_connect_components
ChatGPTWire component outputs to component inputs. Adds wires; existing wires are kept. Requires the Runchat plugin running in Rhino; Grasshopper opens automatically. Load the "grasshopper-canvas" skill first for the full API reference.
grasshopper_create_components
ChatGPTAdd components to the Grasshopper canvas (by GUID from grasshopper_search_components, or by name), including sliders, panels and toggles with initial values. Adds to the definition; does not remove anything. Requires the Runchat plugin running in Rhino; Grasshopper opens automatically. Load the "grasshopper-canvas" skill first for the full API reference.
grasshopper_create_python_script_components
ChatGPTCreate Rhino 8 Python 3 script components, or update an existing script component in place by passing its instanceGuid as the id. Updating replaces that component's code and, when given, its full input/output lists. Requires the Runchat plugin running in Rhino; Grasshopper opens automatically. Load the "grasshopper-canvas" skill first for the full API reference.
grasshopper_delete_components
ChatGPTPermanently delete components (and their wires) from the Grasshopper definition. Destructive: confirm with the user first. Requires the Runchat plugin running in Rhino; Grasshopper opens automatically. Load the "grasshopper-canvas" skill first for the full API reference.
grasshopper_disconnect_components
ChatGPTRemove specific wires between components. Destructive: the components stay, the listed wires are deleted. Requires the Runchat plugin running in Rhino; Grasshopper opens automatically. Load the "grasshopper-canvas" skill first for the full API reference.
grasshopper_group_components
ChatGPTWrap components in a single labelled Grasshopper group. Only adds a group; components are unchanged. Requires the Runchat plugin running in Rhino; Grasshopper opens automatically. Load the "grasshopper-canvas" skill first for the full API reference.
grasshopper_layout_canvas
ChatGPTAuto-arrange components left to right by data flow (the same layout as organize_nodes). Moves components only. Requires the Runchat plugin running in Rhino; Grasshopper opens automatically. Load the "grasshopper-canvas" skill first for the full API reference.
grasshopper_read_canvas
ChatGPTRead the open Grasshopper definition: every component with its instanceGuid, position and parameters, the wires between them, and any labelled groups. Read-only. Requires the Runchat plugin running in Rhino; Grasshopper opens automatically. Load the "grasshopper-canvas" skill first for the full API reference.
grasshopper_read_component_values
ChatGPTRead the current input and output values of specific components. Read-only. Requires the Runchat plugin running in Rhino; Grasshopper opens automatically. Load the "grasshopper-canvas" skill first for the full API reference.
grasshopper_read_selection
ChatGPTRead the components the user currently has selected on the Grasshopper canvas. Read-only. Requires the Runchat plugin running in Rhino; Grasshopper opens automatically. Load the "grasshopper-canvas" skill first for the full API reference.
grasshopper_search_components
ChatGPTSearch the installed Grasshopper component library by name, nickname, description or category. Returns component GUIDs to pass to grasshopper_create_components. Read-only. Requires the Runchat plugin running in Rhino; Grasshopper opens automatically. Load the "grasshopper-canvas" skill first for the full API reference.
inspect_clip
ChatGPTLOOK at a short window of the raw ClipChat screen recording. ClipChat extracts [start, end] (max 20 seconds) and answers your question about it with a video model. Use it for VISUAL questions where cut precision matters — exactly when a result appears, whether a stretch is idle, what is on screen at a boundary. Narrow windows can be sampled at a high frame rate (see fps), so prefer a short window around the exact moment over a long one. DO NOT use it to decide speech timing: the model is unreliable on audio — it returns different transcripts for the same window on repeat calls, and it readily reports text it can SEE on screen (a chat box being typed into) as words it heard. The transcript's WORD timestamps are the only trustworthy source for when speech happens; segment boundaries are not, and neither is this.
list_models
ChatGPTList the models available to the authenticated user. Type 'media' (default) returns generation models (image, video, audio, 3d) — discover valid model_ids before calling get_model_params or create_image_node. Type 'llm' returns language models for create_prompt_node's model_id. Returns model_id, name, modality, tags, and cost.
list_runchats
ChatGPTList the authenticated user's runchats, most recently updated first. Optionally filter by name (
query), tags, and/or a folder (path or library id). Each result includes the folder it lives in ({id, name, path}), and the response includes the user's folder list so you can file new runchats into existing folders (pass a folder's path to create_runchat).list_training_runs
ChatGPTList the user's LoRA training runs (newest first) with status, base model, trigger word and — once complete — the model_url to use in a lora-capable model's loras parameter. Also returns the available training endpoints (trainer api_ids for start_training with cost/pairs/duration). Active fal and Modal runs are status-checked live.
organize_nodes
ChatGPTAuto-layout nodes by their connections, avoiding overlaps. Call once after creating and connecting. Pass the ids you created — connected nodes are included automatically; nodes the user positioned stay put as anchors.
publish_runchat
ChatGPTPublish this runchat as a reusable tool — a new VERSION each call, never a duplicate. Set name, description, thumbnail, slug and which node parameters are the published inputs/outputs (node_id + param, each with a label and description users see). The lists you pass REPLACE the published set exactly; omit a direction to auto-publish its entry/exit parameters. Returns the version number and public slug.
read_files
ChatGPTRead a code or note node's files: path, line-numbered content, length. Pass
files for specific paths; omit to read everything (do this first when you don't know the paths). Notes have one file, note.md.read_nodes
ChatGPTFull state of nodes by id: each parameter's name, type, label, status and data (truncated to data_limit chars; original lengths are reported). Use it for values, handle names and node data.
read_scene
ChatGPTRead the workflow's shared 3D scene: every object with its id, kind, the numbers it was made from, who last changed it, and the box it occupies in the world (world_min, world_max). Metres, Z up.
read_status
ChatGPTA code node's current errors, status, preview and worker messages — for debugging a failing run.
run_blender_command
ChatGPTRun Python code directly in the connected Blender session via the bridge. The code executes in Blender's Python environment with
bpy available; print() output is captured and returned. Avoid operations that block Blender's main thread for a long time (heavy loops, renders). Returns success, message, and any console output. Requires Blender plugin with runScript and run permission. Call use_skill "blender-python" before writing non-trivial code, and use take_screenshot afterward to verify the result.run_nodes
ChatGPTExecute the listed nodes in dependency order. Unlisted upstream nodes do NOT run — list every node that must recompute. Returns per-node status and, per output handle, the item count and type produced. If the estimated cost exceeds this turn's auto-run budget nothing runs and status is "approval_required" with estimated_credits — get the user's approval, then re-call with approved_credits. Runs the nodes on the user's own canvas and overwrites their previous outputs.
run_rhino_command
ChatGPTRun a Rhino command string, or a one-off Python 3 script, directly in the connected Rhino session via the bridge. Commands use non-interactive scripted syntax (e.g.
_-Circle 0,0,0 5 _Enter, _-SelNone _Enter). With language "python", command is a CPython 3 script (rhinoscriptsyntax/RhinoCommon; print() output is returned) — use this for one-off inspection, edits and fixes; use a rhino-python code node only for a script the user will re-run or wire into the workflow. Avoid dialogs and user picks. Returns success, message, and any new console output. Requires Rhino plugin with runScript and run permission. Use take_screenshot afterward to verify geometry.search_docs
ChatGPTSearch the Runchat documentation (docs.runchat.com): matching sections with urls. Free. Use BEFORE answering anything about the product itself or when the user is stuck in the UI. fetch_page a result url for the whole page.
search_reference_images
ChatGPTReal reference photographs as direct image URLs (title, source, page url, photographer). The default for visual precedent — style, material, lighting, mood — at 1 credit per call (web_search is 10 and returns pages). URLs work directly as image inputs. For images from one SPECIFIC site, fetch_page that site and view_image candidates instead.
start_training
ChatGPTStart a LoRA training run on the user's account. Costs credits (the trainer's listed cost) — confirm with the user before calling. Edit trainers (pairs: true) learn a TRANSFORMATION from before/after image pairs: the dataset zip must contain ROOT_start.EXT (the input), ROOT_end.EXT (the target) and ROOT.txt (the edit instruction for that pair — include the trigger word and phrase it like the prompts that will be used at inference). Style trainers take a flat folder of images with optional per-image captions. The zip must be hosted at a public https URL. Call use_skill "edit-lora-training" first for the full dataset-building recipe. Returns the request_id — monitor with list_training_runs; the finished LoRA's model_url plugs into a lora-capable model's loras parameter.
take_screenshot
ChatGPTCapture a screenshot of the connected CAD application's viewport (Rhino, Revit, Blender, ArchiCAD or SketchUp). The image is uploaded and automatically attached to your next turn so you can see it. When more than one CAD app is connected, pass
host to pick the app you just scripted (otherwise the most recently connected app is captured, which may be a different one); the result notes the other connected sessions when that happens. Requires a connected plugin that supports captureViewport.update_artifact
ChatGPTUpdate an artifact you own and re-publish it. Only the fields you pass change: content (the entry file, or file_path), name, folder, cover image, visibility. get_artifact first for a targeted content change. Returns the public URL.
update_node
ChatGPTUpdate an existing node's label, model, output_format, input values, input_depths, published params, position or lock state. Not for code — use edit_file. artifactNode settings (operation_mode, write_behavior, auto_publish, visibility) go through
inputs. Image inputs are hosted URLs, never base64.update_runchat
ChatGPTUpdate a runchat's organizational metadata: rename it, set its tags, and/or move it into a folder. Only the fields you pass are changed. Use this to keep your runchats tidy after creating them.
use_skill
ChatGPTLoad a built-in guide for Runchat workflow authoring, image prompting, code, desktop scripting, app artifacts, training, or video editing by name. Load only the guide needed for the current task, and reuse instructions already loaded in the conversation.
view_image
ChatGPTSee an image, webpage, PDF page or html node render.
url: an image you haven't seen yet (not one already in the conversation); SVGs are rasterised (format 'source' returns the markup). A webpage URL returns a viewport screenshot (fetch_page to READ text); a PDF URL attaches the whole document if your model reads files; url#page=N with format 'render' (or any PDF url when your model can't read files) screenshots that page as a PNG for image models. node_id: screenshot an html code node's rendered preview — the only way to SEE what your HTML/Three.js renders. If your model can't see images, pass question and a vision model answers in text.view_scene
ChatGPTRender the shared 3D scene and look at it. Objects are labelled name (id) on a metric grid.
web_search
ChatGPTWeb search: title/url/snippet results, 10 credits per call.
write_plan
ChatGPTDeliver edits to ClipChat. A plan is an arbitrary LIST of videos — there is no privileged "main" cut and no separate shorts bucket; a long-form 16:9 edit and three 9:16 shorts are four entries differing only by
aspect. MERGES BY ID: send an existing edit's id to refine that video in place, a new id to add another, and simply omit every edit you are not changing — they survive untouched. Send ONLY what you changed. Rewriting an existing id also requires that edit's current "rev" (from list_edits or an earlier reply): the user edits the plan by hand, so it can change under you — a stale or missing rev is refused, with the edit's current state in the error to re-apply your change onto. Returns {ok, mode, edits: [{id, rev, title, aspect, clips, duration_s, tracks?, needs_render}], dropped: [{id, reason}], next} — always check dropped: an edit listed there did NOT land, and "(edit kept)" entries are fields that were stripped with the replacement named. clips gives every SPINE entry's output span ({src|media|gap, out_start, out_end}) — place track clips ("at" is output seconds) by those spans, and RE-CHECK them after restructuring a cut: free-track clips stay where they are while the footage under them moves. This only writes the plan; rendering is a separate step (clipchat_render). Do not print the plan JSON as text. Defaults to the session the app has open; pass session_dir (from clipchat_list_sessions) to target another.Capabilities
Writes
Example Prompts
Click any prompt to copy it.
