Documentation.
Kaitoi turns models, code, services and domain tools into programmable building blocks you can compose, run and ship. Start with your first project, learn the Studio tools, publish a Station, or build against the API, MCP and local runtime.
Start here
Choose where to work in Kaitoi, create and save your first project, learn the Studio controls, and understand projects, graphs, nodes and runs.
Getting started
- Choose where to work Choose Studio for visual creation, Core for applications and AI clients, or the CLI for local work, then find the right starting point for your task.
- Your first project Create a small test image, change its pattern, save the editable workflow, and download the result while learning Studio’s basic graph controls.
- Finding your way around Locate Studio’s main controls, switch views, find nodes and saved work, navigate a graph, and understand the different controls used on a phone.
Core concepts
- Projects Understand what a project keeps, how the working autosave differs from a saved project, and how to reopen, copy, and update work safely.
- Graphs and nodes Understand node types and instances, manual and connected inputs, typed pins, branches, and how a graph's dependencies shape a run.
- Runs Run the work you need in Studio, understand progress and reused results, stop execution, and keep the outputs that matter.
- Kaitoi Studio and Kaitoi Open Source Compare hosted Studio with the planned Kaitoi Open Source distribution: who runs it, which services are included, where data goes, and what you manage yourself.
Kaitoi Studio
Create with Penny across Studio, build node graphs, work with media, publish Stations, connect models and services, and share projects with your team.
Projects, files and teams
- Saving and recovery Save deliberately, read autosave status, reopen the right work, and recover a backup without confusing a local restore with a successful server save.
- Files and results Inspect current and earlier node outputs, copy useful results to Files, organize personal and team assets, and download copies for use elsewhere.
- Teams Set up a team, choose its workspace, add members with the right roles, share saved work, and manage a pooled credit balance with weekly spending caps.
Penny
- Working with Penny Build graphs, create custom nodes, and make content with Penny. Choose the right context, manage conversations, and distinguish changes from completed results.
- Building and editing graphs with Penny Brief a new workflow, target changes in an existing graph, check inputs and wires, and test the intended output with Penny.
- Creating custom nodes with Penny Create a reusable node with Penny. Define its interface, review generated code and warnings, test known cases, and revise it while preserving its contract.
- Skills Choose the workflows Penny can execute in Lab, configure required plugins, and create or import reusable Skills that produce canvas results.
- Playbooks Give Penny reusable written instructions for a conversation, import a Markdown Playbook, activate it, and maintain a consistent creative method.
Lab
Graphs, nodes and blocks
- Nodes A node is one unit of work with typed pins, its own parameters, its own preview and its own state. Learning to read one is most of learning to read a Kaitoi graph.
- Building a graph Add nodes, connect compatible typed pins, run the intended selection, inspect earlier results, and organize reusable parts of a larger workflow.
- Blocks Build a processing chain with block previews and parameter controls, inspect its history, and keep the same underlying graph available for editing.
- Templates and organization Start projects from reusable graphs, save a template, share its link, and organize nodes and projects without confusing their roles.
Media tools
- Storyboards Plan scenes and shots, organize reference frames, edit their order and duration, and send an intended sequence to Timeline or back to Lab.
- Timeline and export Assemble picture and sound on tracks, trim and inspect clips, configure the output, then render a deliverable or export an interchange document.
- Drawing, masks, and crops Sketch a visual reference, prepare a mask or crop for an image input, compare results, and keep the original source while you experiment.
- 3D models and scenes Inspect models and splats, compose a scene with a 3D Editor node, choose render outputs, and keep useful models or scene results for later work.
Stations
- Create and publish a Station Choose the graph inputs and results visitors receive, check node compatibility, preview a frozen draft, and make a Station live at a stable link.
- Using a Station Supply Station inputs, read the estimate, run a published tool, download results, and resume supported failed work while understanding its costs.
- List a Station in the gallery Submit a Station description and image or video cover, understand review, update a listed card with Send changes, or withdraw the public listing.
Research and knowledge
- Research with AdMuse Use advertising references to develop a grounded creative direction, then turn that direction into a production workflow.
- Knowledge bases and RAG Extract and index document content, keep embeddings compatible, retrieve useful source passages, and use them to ground a model’s answer.
Models and integrations
- Providers and models Choose managed model access, personal provider keys, or local services, and configure the available model list for Penny and your workflows.
- Connect your accounts Authorize external services for workflow nodes, check the account and permissions in use, and reconnect or remove connections when access changes.
- Add external MCP servers Connect Kaitoi to an external MCP tool server, configure authentication, inspect its capabilities, and troubleshoot missing or expired access.
- Local models and services Connect Studio to supported models and services on your hardware, then check the service, runtime, installed recipe, and connection separately.
Sharing and community
- Sharing and embedding Choose read-only project sharing, optional cloning, template links, or runnable Stations, then manage expiry and access for the intended audience.
- Community publishing Discover shared nodes and templates, inspect their requirements and prices, and prepare your own reusable code and workflows for publication.
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.
Kaitoi CLI
Install Kaitoi CLI, work with Code and Crew, connect editors and local services, and automate sessions or recipes with practical guides and API references.
Getting started
- Install and update Install Kaitoi CLI on macOS, Windows, or Linux, choose the command for your work, and learn how to check, download, and apply updates.
- Your first Kaitoi Code session Start Kaitoi Code in a project, inspect it in Plan mode, review a small edit in Build mode, and check the result before moving on.
- Sign-in and configuration Sign in to Kaitoi CLI, save your Code preferences, find the right settings file, and understand which choices apply to a new session.
- Files and state on disk Find Code settings, session logs, audit records, agent worktrees and Crew evidence, and configure project file exclusions.
- Hosted and local models Choose a hosted model or connect your own model server in Kaitoi Code. Learn model selection, local setup, context limits, and where requests go.
- Local model setup Set up Ollama, LM Studio or an OpenAI-compatible model server for Kaitoi Code, with no Kaitoi login or Kaitoi inference charge for local-model turns.
- Costs and budgets Read Code usage, set a credit or step limit, and distinguish model spending, tool charges, external engines, and the limits of a running budget.
Working with Kaitoi Code
- Plan, Build and Crew modes Choose Plan for inspection, Build for approved changes, or Crew for durable delivery with its own reviewed authority and bounds on delegated work.
- Permissions and the sandbox How Kaitoi Code asks before it acts. Trusting a folder, approval cards with diffs, rules you save per project, auto-approve, and the sandbox around commands.
- Files, attachments and edits Give Code the right files and images, use line-specific mentions, review edits, and understand the boundary between workspace access and attachments.
- Commands and background processes Enable model command tools, inspect sandbox and approval details, use your own shell command, and track or stop the background processes Code owns.
- Sessions, history and context Resume or fork a conversation, inspect context pressure, compact long sessions, export useful records, and distinguish a fresh session from file recovery.
- Checkpoints, undo and rewind Recover from an unwanted Code exchange, choose whether files or conversation should go back, and understand skipped files, redo, and checkpoint limits.
- Web research and media generation Research with cited public sources, prepare a media brief, review a generation quote, and recover an existing result when downloading or saving fails.
- Kaitoi projects, graphs and custom nodes Build Kaitoi workflows from Code, inspect real node schemas, distinguish inline runs from saved projects, and validate custom nodes before installation.
- Keyboard shortcuts and slash commands Find Code's keyboard shortcuts and command families, distinguish steering from queueing, and understand how Escape behaves at a prompt or approval card.
Extending Kaitoi Code
- Extensions overview Extend Kaitoi Code with MCP servers, skills in SKILL.md folders, your own slash commands and hooks, each under your control.
- MCP servers Add external tools to Code, resolve user and project server settings, approve the launch, sign in when required, and set separate per-tool grants.
- Skills and project commands Package reusable instructions as a skill, add a project slash command, understand discovery precedence, and keep prompt expansion separate from execution.
- Hooks Run reviewed automation at Code events, configure hook matching and timeouts, and distinguish blocking decisions from context and after-the-fact feedback.
- Project instructions and memory Put durable project guidance where Code can load it, understand parent and nested instruction scope, and keep bounded project memory concise and current.
Subagents and Crew
- Subagents and background agents Delegate a bounded task, choose a role and lifetime, monitor background agents, and distinguish shared-workspace work from worktree isolation and Crew.
- Claude Code and Codex engines Assign subagent roles to Kaitoi, local, Claude Code, or Codex engines, understand credential and billing boundaries, and review the engine's start grant.
- Your first Crew run Define a bounded coding task for Crew, choose its engines and verification commands, and review workspace preparation, checkout mirroring, and budgets.
- Monitor, steer and resume runs Follow the correct Crew run, distinguish pause, interrupt, cancel, and continuation, and use fresh state versions when controlling a durable run.
- Worktrees, verification and results Inspect a Crew candidate and its evidence, understand guarded checkout mirroring, and keep saved work, verified completion, integration, and release distinct.
- Crew command reference Look up Crew commands, run flags, spending limits, continuation grants and recorded phases before starting or recovering a coding run.
Editors and automation
- VS Code extension Connect the VS Code chat view to your installed Kaitoi CLI, add selected code as context, and handle workspace trust, permissions, diffs, and cancellation.
- Connect other editors with ACP Configure an ACP editor to launch Kaitoi Code over standard input and output, resume saved sessions, and handle authentication, context, and permissions.
- Headless runs and JSON events Run one Code turn from a prompt or standard input, constrain workspace authority and cost, and consume JSON events without confusing them with session SSE.
- Local session HTTP API Start a loopback Code server, create trusted sessions, submit messages, follow resumable events, and answer permissions using the local session API.
- Python SDK Connect Python to a running local Code server, iterate one turn or follow a session, answer specific permissions, and cancel work with the correct lifecycle.
- GitHub Actions Configure a bounded GitHub integration, understand comment triggers and runner authority, and distinguish a dry run from remote comments, pushes, and PRs.
Local services and recipes
- Connect local services Bring a local Runtime or model service into Kaitoi through a tunnel, distinguish service health from readiness, and stop the resources you actually started.
- Install and run recipes Find recipes, inspect requirements, install and run them with declared inputs, and connect their outputs to Studio while keeping local and cloud files distinct.
- Create recipes Define a recipe with YAML and a companion script, map inputs to command arguments, collect declared outputs, and distinguish generation from verified execution.
- Runtime API Submit local recipe jobs, poll their status, upload inputs and retrieve outputs, and distinguish Runtime's short-lived job store from Code's session API.
More guides
Account and help
Understand Kaitoi plans, availability, credits and costs, manage privacy and permissions, troubleshoot workflow problems, and follow product updates.
Plans and credits
- Plans and availability Check personal and team plan access, included credits, seats and current offers, then diagnose the other requirements behind unavailable features.
- Credits and costs Read estimates and actual charges, understand available and held balances, and find project and account spending records.
More guides
- Privacy and permissions Understand which owner, provider, recipient, or connected tool receives workflow data, and manage sharing, permissions, and access deliberately.
- Troubleshooting Identify whether a failure belongs to inputs, execution, provider access, files, saving, or an external client before retrying.
- Versions and updates Distinguish application, project, Station, node-package, and local-tool versions when checking compatibility, updating work, or reporting problems.
API reference
Every endpoint, generated from the running API rather than maintained by hand, so it cannot drift from what the server actually accepts.