Skip to content

Build with an agent

Connect a coding agent such as Claude Code to the runtime Tato Studio runs, and build together, with each of the agent's edits landing live in Studio and in its History.

The runtime speaks MCP, the protocol coding agents use to call tools. Connect an agent to the runtime Studio runs, and the agent works on the same project you have open: it reads the graph and the logs, writes nodes, places and wires them, and sets their values. Each edit it makes shows up in Studio as it lands, so you can watch it build, take over, and hand back.

Studio links the tatolab command for you. If tatolab isn’t found in a terminal, open Edit › Settings… › Command line and press Link tatolab.

Then add the runtime to your agent. For Claude Code, run this once, in the project’s folder or anywhere with --scope user:

Terminal window
claude mcp add tatolab -- tatolab mcp

For an agent configured with JSON, such as Cursor or Claude Desktop, Settings › Command line shows the .mcp.json to add:

.mcp.json
{
"mcpServers": {
"tatolab": {
"command": "tatolab",
"args": ["mcp"]
}
}
}

The agent starts tatolab mcp, which reaches the runtime through a local socket that only your user account can open. Nothing listens on the network.

Open the project in Studio, with the stream graph, the Node visualizer and History in view, and start your agent next to it. Then ask for what you want:

  • “Add a blur after the camera, and make it subtle.” The agent reads the graph, places a Blur, wires it in, and sets its value. The card appears in Studio, wired, and the visualizer shows the result.
  • “Write a node that counts the people in the picture, and put it after the camera.” The agent creates a node file, writes its code, places the node and wires it. Open the file in Studio’s Code view to read what it wrote.
  • “Why is the detector’s output empty?” The agent reads the graph’s states and counters and the project’s log, and tells you what it found.
  • “Make this a stream of its own, and use it in both outputs.” The agent collapses the nodes into a subgraph and places it where you asked.
  • “Play the project and tell me if anything fails.”

Keep editing in Studio while it works. Your edits and the agent’s go to the same runtime, one after another, and each is applied whole or refused whole, so neither of you can leave the graph half-changed.

History lists every edit with its author: yours as You, the agent’s under its name. Each author undoes only their own: Edit › Undo takes back your last edit, never the agent’s, and the agent’s own undo takes back only what it did. Ask the agent to undo something, or open History to see exactly what changed.

The agent’s edits are saved with the project like yours. Its graph edits are in the stream’s graph document, and the files it writes are in the project’s folder, on the same history.

The runtime gives an agent the same operations Studio uses:

  • Read: the streams, each graph with its states and counters, the node catalog with every node’s pins and descriptions, the project’s files, assets and log.
  • Build: add, connect, rename and remove nodes; set values and settings; group, note and collapse nodes into subgraphs; create node files and write code; import assets; add and rename streams.
  • Run: open, play, pause, stop and reload projects.

Descriptions pay off here: the agent learns what your node does, and what each setting means, from the @node.meta description and the descriptions on its pins and settings, exactly as Studio shows them.

Agents and MCP lists every tool and the recipes the runtime offers, and connecting an agent to a runtime on another machine.

  • What the agent reads goes to its model provider. Graphs, logs and files it reads go into its context. Decide for each project whether that’s fine.
  • An agent changes the running project. Its edits play at once, just like yours. Work on a copy, with Duplicate in the Projects window, when a project is on air.