Read-only health check + TouchDesigner server info. Returns {connected, endpoint, touchdesigner version info, knowledge-base stats, bridge_stale?} and changes nothing. Use this first to confirm the bridge is reachable; it succeeds even when TD is offline, reporting connected:false with the reason. Also warns when the running Python bridge is older than this build (a common gotcha — editing td/ doesn't reload the running bridge), pointing you at reload_bridge.

Create a single bare operator (node) inside a parent COMP — nothing is wired or laid out. Validates the operator type against the knowledge base and warns (without blocking) on unknown types. Returns {node, warnings[]} for the created node. This is the atomic primitive: for a complete wired+arranged network prefer the higher-level Layer-1 create_* tools (e.g. create_audio_reactive, create_feedback_network).

DESTRUCTIVE by default: permanently remove one node from the project by path (a COMP also takes its children with it); this cannot be undone via the API. Prefer mode:'bypass' when you only want to disable a node — it turns the bypass flag on (reversible) instead of destroying it. Returns {deleted|bypassed, mode}. Only call delete mode when the user explicitly asks to remove a node.

Modify an existing node by setting one or more of its parameters to constant values. The update is strict (not best-effort): an unknown parameter name fails the whole call atomically without changing anything, and a bad value (wrong type or out of range) returns an error naming which parameters applied and which failed. On success returns the updated {node}. To inspect valid parameter names/current values first use get_td_node_parameters; to make a parameter move over time use animate_parameter instead of a static value.

Read-only: list the DIRECT child nodes of one COMP. Defaults to a compact summary (count + type breakdown + sample paths); pass detail_level:"full" or path_only:true for the complete list, and pattern to filter by name. Returns {count, by_type/sample or paths/nodes}. Use this to browse one level; use find_td_nodes to search recursively and by operator type, or get_td_topology when you also need the connections between nodes. Token economy: keep the default compact summary and scope with pattern; only request the full list when you truly need every path, and avoid re-listing a path you already inspected.

Read-only: read the current parameters (and inputs/outputs) of one node. Returns {path, type, name, parameters, inputs, outputs}. Pass keys to project specific parameters or omit_io:true to drop the inputs/outputs lists. Use compare_td_nodes to diff two nodes' parameters at once. Token economy: pass keys to fetch only the parameters you care about and omit_io:true to drop inputs/outputs — a full parameter dump is large.

Read-only: for each parameter of a node, report its mode (CONSTANT / EXPRESSION / EXPORT / BIND), its evaluated value, and its raw expression / bind-expression / export-source strings. Use this to faithfully serialize a network for round-trip editing, diffing, or debugging — the evaluated value alone hides which parameters are driven by expressions or exports. Set non_default_only to surface only the parameters that would be lost in a plain value copy.

Read-only: check one node (or, with recursive:true, its whole sub-network) for cook/compile errors and warnings. Pass summary:true for grouped counts instead of the full list. Returns {total, errors[] or by_type}. For a large network prefer summarize_td_errors, which clusters errors by shared cause and points at the worst-offending nodes.

Escape hatch — run an arbitrary Python script inside the TouchDesigner process. Prefer the structured tools (find_td_nodes, get_td_node_parameters, update_td_node_parameters, summarize_td_errors, snapshot_td_graph, …); reach for this only when no structured tool can express the operation. Code runs in TD only, never on the local machine.

Escape hatch — invoke an arbitrary Python method on a node (operator). Prefer structured tools where one exists; use this for operations they don't cover (e.g. .cook(), .copy(), .destroy()).

Read-only: list TouchDesigner Python API class names from the embedded knowledge base (works offline, never touches TD). Returns {classes[]} of name/displayName entries. Optionally filter by name. Use get_td_class_details or get_module_help to expand one class into its members and methods.

Read-only: full STRUCTURED documentation for one TouchDesigner Python class (members + methods) from the embedded knowledge base (offline). Returns the class object, or {found:false, suggestions[]} of near-name matches if unknown. Use get_module_help instead when you want the same content as ready-to-read Markdown rather than structured JSON.

Read-only: human-readable Markdown help (description, members, method signatures) for a TouchDesigner Python class or module, from the embedded knowledge base (offline). Returns formatted text, or {found:false, suggestions[]} of near-name matches if unknown. Use get_td_class_details instead when you need the same information as structured JSON to process in code.

Read-only: report cook times under a network (recursively by default, slowest node first) and warn about nodes that exceed the frame budget. Returns {targetFps, frameBudgetMs, totalCookMs, nodes[], warnings[]} and changes nothing. Use this to just measure; use optimize_performance when you want suggestions and the option to auto-shrink the slow TOPs.

Read-only: return the nodes AND the connections (wiring) under a network root, flagging obvious structural issues. Returns {nodeCount, connectionCount, issues[], topology}. Use this when you need how nodes are wired together; use get_td_nodes/find_td_nodes when you only need the node list without connections, or snapshot_td_graph when you also want each node's parameters captured for diffing. Token economy: point it at a specific network root rather than the project root, and leave recursion off unless you need nested networks.

Read-only: search a network for nodes by name pattern and/or operator type, recursively by default. Returns {count, truncated, matches/paths}. Prefer this over get_td_nodes when you are looking for specific nodes anywhere in a sub-tree (get_td_nodes only lists one COMP's direct children); use get_td_topology when you also need the wiring between them.

Read-only: collect errors across a network and cluster them by message, type, or parent container, with the worst-offending nodes and a suggested order to investigate. Returns {total, groups[], suggestions[]}. Use this for network-wide triage instead of reading every node's errors one by one; use get_td_node_errors when you just want the raw error list for one node or sub-tree.

Read-only: diff the parameters of two nodes, returning only the values that differ (by default). Returns {type_match, differing_count, differing[], same_count}. Useful for aligning settings across similar operators; compares two live nodes, whereas diff_snapshots compares two whole-network snapshots over time.

Read-only: capture a compact, serializable snapshot of a network — nodes, connections, structural issues, and optionally each node's parameters — for review, diffing, or documentation. Returns {nodeCount, connectionCount, issues[], nodes[], connections[]}. Set compact for a token-cheap whole-COMP read that hoists per-type default parameters and stores only each node's deltas. Feed two of these snapshots to diff_snapshots to see exactly what changed across an edit.

Hot-reload the bridge's Python inside the running TouchDesigner, so edits to the td/ modules take effect without reopening the project. Reimports every loaded mcp./utils. module in place and returns the list reloaded. Use after editing bridge code.

Search the embedded operator knowledge base (629 operators) by keyword, exact name, tag/keyword, category, subcategory, parameter metadata, or TouchDesigner version compatibility — ranked by relevance, fully offline by default. Use it to discover the right operator before creating nodes instead of guessing a type (e.g. 'what sends DMX?', 'particle', 'corner pin'). Returns name, family, summary, facets and optional matching parameters. Pass semantic:true to re-rank fuzzy candidates by embedding similarity (needs an LLM endpoint; falls back to keyword). With parameter_search, matched Menu parameters include their menu options; results are stamped with a data_version (which TouchDesigner build the offline catalog reflects) and a stale_hint when the connected TD is on a different major. Token economy: use a specific query and a small limit; one focused search beats several broad ones.

Read-only: compare two TouchDesigner operator types from the embedded offline knowledge base, including overview metadata plus shared and unique documented parameters. This compares operator documentation, not live node settings; use compare_td_nodes for live node parameter diffs.

Read-only: return an embedded TouchDesigner operator workflow guide with common inputs, outputs, examples, and next-operator suggestions. For unknown operators, returns candidate guide ids instead of failing.

Read-only: suggest a small ordered TouchDesigner operator chain for a creative or technical goal from offline operator docs and workflow patterns. Returns connection hints and next tool hints; it does not create nodes.

Read-only: validate an ordered TouchDesigner operator chain against embedded operator docs, documented connections, family/category filters, and optional TouchDesigner version compatibility. It does not create or modify TD nodes.

Read-only: convert an ordered TouchDesigner operator chain into a RecipeSchema draft without writing files or touching the TD bridge.

Read-only: inspect embedded TouchDesigner technique packs and individual techniques, with optional code snippets and setup/workflow details.

Read-only: convert an embedded TouchDesigner technique with GLSL source into a RecipeSchema draft without writing files or touching the TD bridge.

Read-only: extract a conservative operator chain from an embedded TouchDesigner tutorial and draft a RecipeSchema JSON without writing files or touching the TD bridge.

Read-only: list embedded TouchDesigner tutorials, search tutorial metadata/content, or retrieve one by id/name. With include_content, the content is capped (~30K chars) and comes with a sections_available list; pass a section title to drill into just that part instead of pulling the whole document.

Read-only: search TouchDesigner Python API classes, methods and members from the embedded offline knowledge base. Supports class category filters and conservative stable-version compatibility filtering where compatibility metadata exists.

Read-only: plan a TouchDesigner stable-version migration from offline release highlights plus operator and Python API compatibility records. Returns upgrade boundaries, focused compatibility deltas, and an operator checklist without touching TouchDesigner.

Read-only: search the embedded TouchDesigner knowledge router across operators, operator workflows, examples, versions, compatibility notes, technique packs, TD classes, and experimental build notes. Returns normalized results with resource URIs and tool hints for deeper lookups.

Search, list, inspect, doctor, dry-run install, stage, and uninstall manifest-driven TouchDesigner community packages. Dry-run is the default. Installs stage packages under ~/.tdmcp/packages and only import into TouchDesigner when the bridge is reachable and the package has a safe .tox import path. This tool never runs third-party scripts, pip installs, model downloads, or external app setup.

Document an EXISTING network: read its nodes and connections and return a readable map — counts by operator family and type, plus a Mermaid flowchart of the data flow you can paste into docs. Unlike plan_visual (which plans from a description), this describes what's actually in the project. Use it to explain or hand off a patch.

Compare two network snapshots (from snapshot_td_graph) and return a readable diff: which nodes were added or removed, which connections changed, and which parameters changed (with before/after values). Snapshot before an edit and after to see exactly what changed, or to version a patch over time. Pure analysis — touches nothing in TouchDesigner.

Scan a network for cook-time bottlenecks and (optionally) fix them. By default it reports the slowest nodes with a concrete suggestion each. With apply:true it lowers the resolution of the flagged TOPs by scale to claw back GPU time. Run get_td_performance first if you just want the numbers; use this to act on them.

Save a TOP to an image file at its native, full resolution (PNG/JPG/EXR/TIFF by extension) — for exporting a finished frame, unlike get_preview which only transfers a small inline thumbnail. The file is written by TouchDesigner on the TD machine; pass an absolute path.

Record a TOP to a movie file (.mov/.mp4) via a Movie File Out TOP — for exporting a clip or a loop, where render_output only saves a single frame. start begins recording (pass file, fps); pass seconds to auto-stop after a fixed length, or call stop to finish (stop also cleans up the recorder node). The file is written by TouchDesigner on the TD machine. For individual numbered frames, use render_output per frame.

Reconcile the operator knowledge base against the RUNNING TouchDesigner's ground-truth creatable-optype list (GET /api/optypes). Flags which documented operators are actually creatable in this build vs deprecated/unavailable, and (optionally) which live optypes the knowledge base doesn't yet document. Pass a single operator name to check just that one. Survives TDMCP_BRIDGE_ALLOW_EXEC=0.

Diagnose a network for cleanup: report likely-dead operators (zero wired outputs, unreferenced, not displayed), broken external-file dependencies (file parameters pointing at missing files), orphan COMPs, and a dependency map of which operators reference which. Read-only and conservative — every flagged item carries a human-readable reason. Complements plan_visual (which plans a build) and snapshot_td_graph (which dumps structure).

Produce a Markdown project document for any COMP or project: family/type counts, custom-parameter table, inputs/outputs, child inventory, external file dependencies, and an optional preview thumbnail of the output TOP. Use include_mermaid to add a Mermaid flowchart and max_nodes to cap large inventories. Returns the full Markdown on the structured channel under markdown.

Surgically replace a substring inside a Text or Table DAT's .text. Without replace_all, requires exactly one match — 0 or >1 occurrences is an error, forcing the caller to add context or set replace_all. Use set_dat_content to overwrite an entire DAT's text in place; use this to make a targeted edit.

Overwrite a Text or Table DAT's entire .text with new content. Unlike edit_dat_content (which makes a surgical find-and-replace), this replaces everything in one shot — use it to deploy a full script or template. Refuses to write empty/whitespace-only text unless confirm_wipe:true is passed, preventing silent data loss.

Set one or more parameters on a node to an expression, bind expression, or constant value without needing the raw-Python escape hatch. Supports five modes: 'expression' (par.expr = ...), 'bind' (par.bindExpr = ...), 'constant' (par.val = ...), 'reset' (restore the parameter default via par.reset()), and 'unbind' (freeze the current evaluated value as a constant, dropping the driver). Multiple assignments are applied fail-forward — per-item failures accumulate as warnings so a partial batch still returns useful results. Batches using reset/unbind run through the exec path and require TDMCP_BRIDGE_ALLOW_EXEC=1. Use this instead of execute_python_script when TDMCP_RAW_PYTHON is off.

Emit a project-local CLAUDE.md / AGENTS.md seeded with tdmcp operator conventions and TouchDesigner render-coordinate rules, so a future agent working on this project starts with the right mental model. A small dynamic header (project name, node count, top families) is prepended to a curated static body. Pass output_dir to also write the file to disk on the machine running TouchDesigner. The guide is always returned in the structured result.

Remove one or more input wires from a node in TouchDesigner. By default removes every incoming wire into to_path; narrow the scope with from_path (only wires from that upstream node) and/or to_input (only that input slot index). Returns the list of removed wires (input index + upstream node path), a probe of the Connector API attributes seen at runtime, and any per-wire warnings. Fatal only when to_path is not found — partial removals with per-wire warnings still succeed. The inverse of connect_nodes.

Read-only: report each node's operator flags (bypass / render / display / lock / allowCooking / clone) plus index-aware input wiring, network position, color and comment — the signals that explain a black/blank output that a parameter dump hides. Scan one node or a subtree (recursive); set only_problems to surface just the ops whose flags or cook errors would suppress output. Returns structuredContent for code to process.

Read-only: inspect a single operator's runtime telemetry — cook time, cook count, last-cook frame, resolution (TOPs), channel/sample counts (CHOPs), GPU memory usage, cook errors, and optional Info CHOP channels via include_info_chop. Complements get_td_performance (which aggregates cook times across a network) by providing deep per-op detail for the 'why is it black / why is it slow' diagnostic loop. Returns {path, type, family, cook_time_ms, cook_count, last_cook_frame, resolution, num_chans, num_samples, gpu_memory, info_chop?, errors[], warnings[], extra}. Attribute names are flagged UNVERIFIED and vary by TD build; the extra map records which attrs were actually present for live confirmation.

Read-only: sample one TouchDesigner operator over a short interval and return runtime state, readable parameter values, and CHOP channel values when available. Missing TD attributes/channels are reported as warnings instead of failing the watch. Returns {path, requested_samples, collected_samples, interval_ms, window_ms, warnings[], snapshots[]} where each snapshot has {sample_index, elapsed_ms, path, type, family, state, parameters, channels, warnings}.

Opt-in: subscribe to param.changed events for an operator's parameters. When a watched parameter's value changes in TouchDesigner (by a human or a script), the bridge broadcasts a {path, par, prev, value, frame} event on the TD event stream, forwarded to the MCP client as a logging notification. Use action='watch' to register (optionally scoped to named parameters), 'unwatch' to remove, and 'list' to see active watches. Events only arrive when the server's TD event stream is enabled (TDMCP_EVENTS); param.changed is treated as a high-frequency event (coalesced bridge-side so a slider drag can't flood). Survives TDMCP_BRIDGE_ALLOW_EXEC=0.

Read-only: collect recent cook errors and warnings from the running TouchDesigner project for debugging. Walks the operator tree under scope and gathers each operator's current cook errors and warnings (guaranteed). Also attempts a best-effort probe of textport/log DATs if they exist in the project. Use this when a script or cook fails and you need more context than the immediate error string — it surfaces the real Python traceback or operator cook errors without requiring a new REST endpoint. Returns {lines[], count, probe} where probe reports which log sources were reachable in this TD build.

Read-only: inspect what a COMP exposes — its Python storage dict (keys + values), its extension class descriptors (name, promoted flag, public members), and its custom-parameter definitions (page/name/style/default). Closes the inspect side of the reusable-component loop: use after scaffold_extension + add_custom_parameters to verify what was built, or call standalone to examine any COMP without resorting to raw Python. Returns structured data for agent code-path consumption. API names vary by TD build; the probe field records which attributes were reachable.

Read-only: serialize a COMP's immediate children into a git-diffable JSON spec — each node's name, op type, parameters (with mode + expression, not just the evaluated value), input wires by source node name, and position — plus best-effort custom-parameter definitions. This is the serialize half of a round-trip pair: feed the output spec to rebuild_network to reconstruct the subtree. Use it to snapshot a network as text you can diff across edits or commit to version control. Returns {root, nodes[], truncated?, warnings[]}.

Make a COMP self-contained: recursively scan its subtree for external file references (movie/image files, fonts, LUTs, externaltox links — reusing the collect_project_assets scan), COPY each existing asset into /assets/, rewrite each referencing parameter in the LIVE network to the copied relative path (assets/), then save the COMP as a .tox beside its assets with a tdmcp-component manifest. The result is a folder you can move to another machine and open without broken links. Delta vs make_portable_tox (which saves the .tox only, leaving external assets behind) and collect_project_assets (which only reports refs). Rewriting mutates the live network — set rewrite_refs=false to copy-and-report without touching parameters.

Scan a COMP subtree for every external file dependency (movie/image file pars, fonts, LUTs, externaltox links) and report each referenced file, the node+parameter that references it, and whether the file currently exists on disk. The TouchDesigner scan is read-only and copies/rewrites nothing in the network; when out_manifest is set, this tool writes that local JSON path and may overwrite an existing manifest. File-par detection uses par.style ('File'/'Folder') when readable, falling back to a suffix/exact name heuristic (file, fontfile, lut, externaltox, moviefile, imagefile) — both UNVERIFIED across TD builds; style_supported records whether par.style was available.

Compose a one-folder handoff/portfolio documentation PACKAGE for a network: a README.md (title, node count, per-family summary, how-to-load note), a topology.md with a Mermaid graph of the connections, and - when include_thumbnails is set - preview PNGs of output TOPs under thumbs/ linked from gallery.md, all written into out_dir. Unlike generate_readme (a single file), this assembles a small multi-file site folder for sharing or archiving a project.

Read-only: render a TOP's preview and return a plain-text description of it — the headless 'is the output alive?' primitive. Two paths: (a) a configured vision LLM endpoint when available, (b) a DETERMINISTIC luma/colour-histogram fallback decoded from the preview PNG pixels (always works, no model needed). Reports dominant colours, mean luma, near-black fraction, a coarse classification ('black'/'very dark'/'dark'/'bright'/'colorful'/'mid'), and a friendly caption. Returns {node_path, width, height, source:'vision'|'histogram', caption, stats{...}, warnings}. Use it after a build to confirm the network is actually rendering instead of a black frame. The vision path is currently inert (no vision field on the tool context) and falls back to the histogram.

Bounded, autonomous repair: scan cook errors under a subtree, classify each, and plan a safe fix, capped at max_steps so it can never run away. Defaults to dry_run (PLAN only, no changes). Set dry_run:false to apply the known-safe fixes — resetting a broken parameter expression to constant mode, and re-enabling a bypassed/display-off op — within the same bound; risky cases (DAT syntax errors, missing inputs, unclassified errors) are always PLAN-only. Re-checks errors after applying and stops at the bound or when errors clear. Returns {parent_path, dry_run, max_steps, errors_before, errors_after, steps[], remaining[], warnings, rolled_back}. Use it as the diagnostic 'try the obvious safe fixes' loop after a build; for raw triage use summarize_td_errors / get_td_node_errors instead.

Offline semantic linter for recipes/*.json. Checks schema, id/filename match, duplicate node names, unknown operator types, dangling connections, bad parents, render-outside-geometryCOMP, missing parameter nodes, unresolved control bind_to, GLSL uniforms on non-GLSL hosts, and hygiene (tags/description/preview_description). Returns a structured report; never calls TouchDesigner.

Read-only: score a built network 0–100 on a fixed rubric (palette/motion/complexity/errors/perf) and return per-criterion sub-scores plus deterministic improvement suggestions. Optional LLM critique when llmCritique=true and ctx.llm is configured. Composes existing bridge endpoints — creates nothing.

Read-only: sample cook times over a window (N samples × intervalMs) and rank hotspot nodes by p95 cook time. Use this to diagnose intermittent stalls that a single get_td_performance snapshot misses. Returns {path, samples, intervalMs, targetFps, frameBudgetMs, windowMs, hotspots[], warnings[]}.

Drive the TouchDesigner project timeline: play, pause, seek to a frame, jump to a named cue, or set playback rate. Returns the timeline state after the action so a copilot can verify the change took effect. NOTE: pausing will freeze any downstream motion/feedback/frame-diff chain — expected behaviour, not a bug.

Read-only: returns the host GPU info (name, driver, VRAM), attached monitor topology (resolution, refresh rate, primary flag, position), and whether the project is in Perform Mode. Use to plan output mapping, dome rigs, and multi-display shows without leaving the chat. Offline-safe — returns { connected: false, reason } when TD is unreachable.

Read-only: check whether TouchDesigner is reachable, whether display/projector topology matches expectations, and whether generated sensor/helper status DATs such as source_status or bridge_status are healthy. This is a room/hardware preflight for physical installations; it returns PASS/WARNING/FAIL/UNVERIFIED checks without mutating the TD project.

CRUD operations on a COMP operator's .storage dictionary. Actions: list (all keys+values), get (one key), set (write a key), delete (remove a key). No operators are created; the target COMP must already exist.

Use the schema + LLM to propose values for a tool call's missing required args.

Sample dominant colors from a TOP by capturing its preview PNG and running deterministic k-means on the decoded RGB pixels. Returns {source_top, k, width, height, pixels_sampled, hex_colors[], swatches[{hex,rgb,weight}], warnings[]} sorted by dominance (most-frequent cluster first). Feeds AI grading prompts, create_palette, and design hand-offs. Read-only; no nodes are created or modified.

Walk a SOP's primitives via the bridge and emit an SVG document of polylines (each primitive becomes one <polyline>). Projects to x/y (drops z), auto-fits viewBox, supports stroke/fill/scale/flip_y. Writes to disk when output_path is supplied and always returns the SVG string in the report. Pen-plotter / laser / print deliverable.

Change an operator's TYPE while preserving its name, position, incoming + outgoing wires, and any parameters that exist on the new type. Snapshots wires + params, deletes the old node, creates a new node of new_type at the same parent/name/x/y, re-applies matching params (others go into dropped_parameters), and rewires connectors. Fail-forward: per-wire / per-param failures are reported as failed_inputs[] / failed_outputs[] / dropped_parameters[] rather than aborting. Returns {old_type, new_path, preserved_parameters, dropped_parameters, reconnected_inputs, reconnected_outputs, failed_inputs, failed_outputs, warnings}.

Capture a TOP as a preview image and ask the configured multimodal LLM a question about it. Returns {source_top, question, width, height, answer, model?, stop_reason?, warnings[]}. Uses ctx.llm.complete() with a MultimodalMessage (text + image part). Requires an LLM backend (TDMCP_LLM_BASE_URL / MCP sampling); returns a friendly error otherwise. Different from caption_top, which is deterministic-by-default — this tool ALWAYS routes through the vision model with the artist's custom question.

Read-only one-shot inspection of a TOP: small base64 thumbnail (default 256² JPEG) + parent error sweep (BFS up parent_depth hops) + top-N changed-from-default parameters + cook stats. One call instead of chaining get_preview / get_td_node_errors / get_td_node_parameters when you just want to know 'is this op alive and healthy?'. Use get_preview/render_output for delivery-grade frames; this thumbnail is intentionally tiny + lossy.

Read-only: compress a TD subtree into a structured digest under max_tokens (default 500). Returns {header, nodeCount, connectionCount, primaryOutput, families{count,topTypes}, outputChain, errors{total,topGroups}, warnings, approxTokens}. Uses getNetworkTopology + getNetworkErrors — no new bridge work. Cheaper than get_td_topology / snapshot_td_graph for planning turns.

Read a Text or Table DAT with pagination so a large table cannot flood context. Returns total row/col counts, a header (table DATs), a sliced page (offset/limit), an optional stable head preview (preview_rows), and a row_range only on a partial read. Table DATs are split on tabs/newlines client-side — that split is lossy if a cell embeds a literal tab or newline (probe live before relying on it). Use edit_dat_content/set_dat_content to write.

Read-only: for each menu parameter of a node, live-fetch the menu option values (menuNames — the machine values you set with par.val), their human-readable UI labels (menuLabels), and the currently selected value (current). Use this before setting a Menu / StrMenu parameter so you pick a valid option instead of guessing. Values come straight from the running TouchDesigner build, so they are authoritative and even include dynamically-populated menus (device lists, file menus) — an empty menuNames on a known-menu parameter means the menu has not populated yet (the node has not cooked / the device is not enumerated), not that there is no menu. Requires TDMCP_BRIDGE_ALLOW_EXEC=1; when raw exec is unavailable it falls back to the bundled catalog and attaches a stale-catalog warning.

Pan/zoom TouchDesigner's Network Editor to frame the given operators — a 'follow' move so the artist sees what the agent just built instead of hunting for it. UI-only: it points a Network Editor pane at the operators' parent, selects them, and homes on the selection with zoom. Changes nothing in the project graph.

Create multiple nodes and (optionally) connect them in sequence. Returns all created paths; on failure it stops and reports partial progress without deleting anything.

Wire one node's output connector into another node's input connector inside TouchDesigner, creating a single link between two existing nodes. Uses the bridge's batch endpoint when available and falls back to a Python connect otherwise. Use create_node_chain instead when you are creating several new nodes and want them auto-wired in sequence. Returns the source and target paths, the connector indices used, and which method made the connection.

Create a GLSL TOP under parent_path that renders a custom fragment shader (and optional vertex shader). The shader source is placed in companion Text DATs (<name>_frag and, if given, <name>_vert) and wired to the GLSL TOP's pixel/vertex parameters; numeric uniforms are best-effort bound on the Vectors page and the output resolution is set. Returns the GLSL TOP path, the fragment/vertex DAT paths, and any warnings (e.g. sampler2D uniforms or uniform binds that need manual wiring).

Create one DAT under parent_path preloaded with your Python code. dat_type chooses a Text DAT (plain code), an Execute DAT (event hooks like onFrameStart), or a Script DAT (table builder); for a Script DAT the code is written to its auto-created companion callbacks DAT, since the Script DAT's own text is read-only. Returns the created DAT's path. This only stores code as a node; use execute_python_script instead to run Python immediately against the live project.

Update parameters on multiple nodes in a single batch request. Each update reports its own success; a failure does not roll back the others.

Create one empty COMP under parent_path to hold a visual system, then tile it into the parent's network grid clear of existing siblings. comp_type picks a Container COMP (a 2D panel) or a generic Base COMP. Returns the created node's path, type, and name. Use a higher-level Layer 1 tool instead when you want a fully built, wired network rather than an empty shell.

Expose live controls on a COMP: append custom parameters (sliders, toggles, menus, RGB, pulse) and bind them to node parameters so the artist can drive a generated system in real time. Point comp_path at a system container and list the controls; use each control's bind_to to wire it to one or more 'nodePath.parName' targets.

Build a playable performance panel (a Container COMP of visual widgets) for live use, beyond the parameter dialog: vertical faders that drive parameters, and buttons that recall or morph to named cues (from manage_cue). Open the container in Perform/Panel mode for a touchable surface — faders move their parameters, cue buttons fire scenes (instantly or with a crossfade).

Drive one or more node parameters over time with an LFO (sine/triangle/ramp/square/pulse/random). Creates an LFO CHOP and binds each target so it oscillates between min and max with the given period — movement without manual keyframing.

Drive one or more node parameters from a CHOP channel by expression — the link that makes a visual react. Point it at an audio_features channel (bass/mid/treble/level) or a tempo_sync channel (ramp/pulse/beat) with a scale and offset, and each target parameter tracks that signal live. This is how you wire extract_audio_features / create_tempo_sync into a visual system. Optionally add attack/release smoothing (in seconds) — or a single smooth time — to insert a Lag CHOP between the channel and the parameter so reactivity follows a clean envelope instead of flickering on raw audio (e.g. a fast attack + slow release for a punchy hit that decays smoothly).

Store, recall, list, or delete named snapshots of a COMP's parameter values — the live-performance preset system. Pair with create_control_panel: snapshot the knob positions and jump between looks. Snapshots are saved in the COMP's storage so they persist with the project.

Store / restore / list / delete a full snapshot of a sub-network — an 'undo point' to take before risky live edits. A checkpoint captures every node's constant parameters, the wiring, and node positions. Restoring reapplies parameters, recreates nodes that were deleted since (with their wiring), and prunes nodes that were created since. Unlike manage_presets (custom-parameter looks for performance), this captures the whole network for safe experimentation.

Live-performance scene system: store / recall / morph / list / delete named cues (snapshots of a COMP's custom-parameter values). Unlike manage_presets, a cue can be reached with a timed morph that crossfades every numeric control from the current look to the cue over N seconds (eased), via a small Execute DAT — so you can glide between looks on stage instead of hard-cutting. Recall and morph also take an optional quantize ('beat'/'bar') that defers the change to the next musical boundary (from the project tempo) so scene changes land on the downbeat. Build cues with create_control_panel, then jump or morph between them.

Build a reusable component library by moving COMPs to/from .tox files on disk. Two actions: 'save' writes the COMP at comp_path to file_path as a .tox (overwriting any existing file, optionally creating parent folders) and returns the saved path and byte size; 'load' reads file_path back into parent_path, either as an independent copy or a live-linked instance (via linked) that re-reads the file on change, returning the loaded node's path, type, and child names. Paths are on the machine running TouchDesigner. Marked destructive because 'save' can overwrite an existing file.

Append a custom-parameter page (knobs, sliders, toggles, menus, pulses, RGB, XYZ) to a COMP so a generated network becomes a tunable, reusable component. Point comp_path at the COMP and list the params; an existing parameter is skipped (reported as a warning), not overwritten. Pair with scaffold_extension for behavior and manage_component to save the result as a .tox.

Give a COMP a Python extension class: create a Text DAT holding the class (with optional method stubs), wire it into an extension slot, optionally promote it (so members are callable directly on the COMP), and reinitialize. The other half of making a generated network reusable — pair with add_custom_parameters (knobs) and manage_component (save as .tox).

Add one macro knob (a 0–1 custom parameter) to a COMP that drives many parameters at once, each remapped into its own [min,max] range with an optional response curve — a one-to-many control for sweeping a whole look from a single fader. Targets are bound by expression so they track the macro live.

Randomize a COMP's numeric custom parameters within their slider ranges — an instant new variation for live improvisation. amount blends toward random (1 = fully random, low values nudge the current look). Non-numeric controls (toggles, menus) are left untouched, so it is always safe to fire. Pair with manage_presets/manage_cue to snapshot a happy accident.

Serve a mobile-friendly web panel from a Web Server DAT so you can control a COMP's numeric custom parameters from a phone — just open the URL, no app to install. Each parameter becomes a touch slider that writes back live. SECURITY: like the bridge, this listens on all interfaces and accepts writes with no auth, so use it only on a trusted network. Pair with create_control_panel (the params to expose) and manage_cue (snapshot looks you dial in from the phone).

Bridge TouchDesigner to the outside world: OSC/MIDI input (a control surface — bind incoming channels straight to parameters), OSC/MIDI output (send a CHOP's channels back out for bidirectional feedback to lighting desks, other apps or hardware — pass source_path), DMX/Art-Net output for lighting (dmx_out for any DMX desk; artnet_out for network Art-Net/sACN pixel-mapping of LED strips & stage fixtures), RTMP output to live-stream a TOP to Twitch/YouTube/OBS (rtmp_out — NVIDIA GPU on Windows only), or NDI / Syphon-Spout video input. To discover which channel a control sends (a 'MIDI learn'), wiggle it and read the input CHOP with get_td_nodes, then bind_to that channel. Validate live where possible, but real signal needs the hardware/sender present.

Copy a node or whole COMP (and all its contents) to a new node, placed in the source's parent or another parent_path. Returns the source path and the new copy's path. Use duplicate this way to clone a built network; use create_container instead when you just need a fresh empty COMP.

Tidy an existing network: reposition a COMP's children into a readable left→right data-flow layout (sources on the left, output on the right). Use this to clean up nodes that are piled on top of each other. Set recursive to also arrange the contents of nested COMPs. Only moves node positions — it never adds, deletes, or rewires nodes. Returns the COMP path and how many nodes were repositioned.

Build a live-performance safety control — the 'oh no' button every VJ needs. Wraps a source in a small COMP with two instant kill switches: Blackout forces the output to black (a Level TOP's brightness1 driven to 0) and Freeze holds the last frame (a Cache TOP stops capturing, active → 0). With an input_path the source is pulled in by a Select TOP (so it can live in another container); without one a built-in Ramp TOP test source is used so it builds and previews standalone. Output is a Null TOP. Big Blackout / Freeze toggle buttons are exposed on the container so a performer can hit them instantly. Marked destructive because firing Blackout/Freeze disables the live output. Returns the container, the source/freeze/blackout/output node paths, and the initial toggle states.

Build an Ableton-style clip launcher: a grid panel (Container COMP) of clip buttons, one per named cue (from manage_cue), for fast hands-on scene switching during a live set. Open the container in Perform/Panel mode and tap a clip to fire its cue — instantly, or (with morph_time) crossfading to it over N seconds (eased, the same engine manage_cue uses). Store the cues with manage_cue / create_control_panel first.