Kaitoi Core.
Connect through the REST API or MCP, edit and run workflows, inspect files and results, recover from errors, and build custom nodes and plugins.
REST API
- Quickstart Get a scoped REST key, discover a node schema, submit one inline graph run, follow its status and events, and recover uncertain submissions safely.
- Authentication, API keys and scopes Choose a server or browser API key, grant the scopes your integration needs, configure its origin policy, and keep credentials out of public code.
- Discover nodes and templates Discover current node schemas and owned template endpoints, preserve their identifiers, follow opaque cursors, and build requests from the returned contract.
- Projects and graph documents Discover node schemas, edit a versioned graph document through the public API, and reconcile changes without overwriting another client’s work.
- Runs, progress and cancellation Submit API runs from saved or inline graphs, observe their lifecycle, cancel work, recover uncertain submissions, and retain the outputs you need.
- Files and outputs Reserve and complete uploads, follow signed storage instructions, use stable file IDs in runs, and distinguish temporary download URLs from retained files.
- Timelines and storyboards Validate editable timeline and storyboard documents, convert supported shots, manage versioned project media, and distinguish interchange import from rendering.
- Workflow API endpoints Publish a template's selected inputs and outputs as an async endpoint, choose its authentication path, and build on earlier results.
- Errors, retries and version conflicts Read structured API errors, recover uncertain requests with stable idempotency keys, reconcile version conflicts, and avoid duplicating side effects or spend.
- Interactive API reference (opens in a new tab) The generated interactive REST API reference.
MCP
- Connect an AI client Connect an AI client using your MCP Access URL and scoped authentication, verify its tools, and choose scratch, headless, or attached Studio work.
- Attach to a live Studio session Opt in on a Studio tab, discover and attach its exact session, use revision-guarded actions, and recover uncertain changes without silently switching graphs.
- Build and edit graphs and blocks Discover node schemas, edit the intended graph with revision guards, use grouped block and canvas tools, and keep validation, saving and execution separate.
- Load and save projects Load and save the headless graph, or save a versioned copy of an attached Studio graph while keeping the original project and unsaved work open.
- Create and edit custom nodes Read current node rules and source policy, author controlled packages, guard attached script edits with source hashes, and test behavior separately from saves.
- Run workflows and approve costs Inspect credit estimates, choose a scratch, headless or attached run, and retain the original execution receipt for safe retries.
- Results, files and Run Inspector Inspect MCP executions, retrieve omitted values by version, open supported Run Inspector results, retain files, and cancel the intended run or relay action.
- Work with storyboards and timelines Read consistent media snapshots, use revision-guarded grouped timeline and storyboard commands, and distinguish editor changes from transfers and rendering.
- Build applications with Kaitoi Discover callable workflow contracts, generate exact REST request bodies through MCP, choose key placement, and separate application authority from execution.
- Permissions and troubleshooting Diagnose missing MCP tools, attachment and revision failures, quote refusals, uncertain actions, omitted results, and unavailable Run Inspector presentation.
Custom nodes and plugins
- Writing custom nodes Declare a node's interface with comment directives, implement its run function, and use the supported runtime rather than backend internals.
- Agents and plugins Compose tool-capable nodes, connect compatible plugins, configure their inputs, and keep iterative execution bounded and observable.
- Node and data reference Find an operation’s current schema, read pin names and data types, check its controls and requirements, and use the right value representation.