DISPATCH.AI

getting started

What is DISPATCH.AI?

DISPATCH.AI is an open-source, MIT-licensed visual canvas — an IDE for building AI agent workflows. Instead of prompting a chat window in a loop, you lay your work out as a graph: each step is a node, each node runs a model with tools, and edges carry output (and control) from one node to the next.

You wire the work once and press Run. The chain executes top-to-bottom, every node reports live status, and edges animate while data flows downstream. It runs fully on your own machine or self-hosted infrastructure — no telemetry, no cloud lock-in.

heads up

Documentation will be moved shortly under markdown files in the main repository!

note

This documentation will soon include rapid graph and RAG-based support for our internal tools, such as our copilot, to recall.

Quickstart

Three moves get you from blank canvas to a running chain.

Place nodes. Drag node types from the palette onto the infinite canvas — start with an Initialiser, then add Investigate, Plan, Create, Review.
Wire them top-to-bottom. Connect each node's output handle to the next node's input. Edges define order and carry data downstream.
Press Run. The chain executes in order. Watch status dots flip idle → running → done and edges march while output flows.

dispatch — quickstart

$ dispatch new my-first-chain      # scaffold a canvas
$ cd my-first-chain
$ dispatch open                   # open the visual canvas / IDE

# place nodes → wire top-to-bottom → then:
› run
Initialiser  done
Investigate  done  web_search → 3 sources
Plan         done
Review       paused → awaiting approval

Install

DISPATCH is local-first. Clone the repository and run it on your own machine — nothing leaves your network. See Self-hosting for production and air-gapped setups.

install

$ git clone https://github.com/h1kv/dispatch-tooling
$ cd dispatch-tooling
$ npm install
$ npm run dev                      # canvas at http://localhost:3000

the canvas

The Canvas

The canvas is an infinite workspace where every capability is a node, a surface, or a switch on one graph. Drag to pan, scroll to zoom, and drop node types from the palette. The graph is the program — it is also a file, so it can be committed, diffed, and reviewed like code.

Nodes & edges

A node holds an instruction, a provider + model, and the tools it may call. An edge connects one node's output to the next node's input — defining both execution order and the data handed downstream. There is no hidden runtime: what you see on the canvas is exactly what runs.

Status & live run

Every node reports state as the chain runs.

idle running done paused error

Context & Memory

Context is shared state across the graph. A node can write a value (for example run.findings or run.plan) and any downstream node can read it — no copy/paste, no manual threading. The Context node makes this explicit on the canvas.

Key	Written by	Read by	Access
run.findings	Investigate	Plan, Create	write · read
run.plan	Plan	Create, Review	write · read
run.draft	Create	Review, Doc	write · read

node reference

Node Reference

Every node type DISPATCH ships with. Mix and match them on the canvas — each runs a model with tools and hands its output downstream.

Initialiser

Entry trigger. Seeds the run with the initial task and context.

Investigate

Researches with live tools (web_search, fetch_url) and gathers sources.

Plan

Turns findings into an ordered plan of phases and steps.

Design

Produces structure, layout, or system design from the plan.

Create

Generates the artifact — code, copy, or documents — from upstream context.

Evaluate

Scores or judges an output against criteria; can branch on the result.

Doc

Writes documentation or summaries from the produced artifact.

Apply

Commits changes — writes files, applies a patch, or executes the result.

Context

Shared memory read/write across the graph (run.findings, run.plan…).

Review

Human-in-the-loop checkpoint. Pauses for Approve / Reject before continuing.

Parallel

Fans one input out to many branches that run concurrently.

Merge

Fan-in: joins multiple branches back into a single downstream output.

Deploy

Ships the canvas to a target — e.g. a GPU pod serving a 70B-class model.

Live tools

Any node can call DISPATCH's built-in tools while it runs:

Tool	What it does
web_search	Search the web and return ranked sources.
fetch_url	Fetch and read the contents of a URL.
read_file	Read a file from the working directory.
write_file	Write or overwrite a file on disk.
list_files	List files and directories in a path.
shell_exec	Execute a shell command and capture its output.

running chains

Running Chains

A chain runs top-to-bottom in dependency order. Each node executes once its upstream inputs are satisfied; independent branches run in parallel. Press Run on the canvas or invoke run from the inbuilt CLI.

Human-in-the-loop

Drop a Review node anywhere to gate the chain. When the run reaches it, the node pauses and surfaces Approve / Reject controls — nothing downstream proceeds until you sign off.

Reviewhuman checkpoint

Parallel & merge

Use a Parallel node to fan one task out across many branches (or many agents), then a Merge node to converge them back into one synthesized result. See Agentic Streaming for deploying 20 agents on a single task.

cli

Inbuilt CLI

A real terminal lives inside the canvas. Drive runs, hotswap models, stream logs, and install skills without leaving DISPATCH. See the Terminal / CLI feature page for the full surface.

Command	Description
run	Execute the whole chain from the top.
stop	Halt the active run immediately.
retry <node>	Re-run a single node and everything downstream of it.
deploy	Ship the canvas to a target (e.g. --pod for a GPU pod).
stream <n>	Tail the live token stream of node n.
model <node>	Hotswap the provider + model for a node, mid-run.
voice	Toggle the agentic VoiceOrb to edit the graph by voice.
install <skill>	Install a community skill; it becomes a droppable node.
status	Show per-node state across the canvas.
logs	Print run logs for the chain or a single node.

dispatch ›

› run
chain started · 5 nodes
› model Create --provider anthropic --model opus
✓ Create → anthropic · opus  (hot-swapped)
› retry Investigate
re-running Investigate + downstream…

features

Features index

Every capability has a dedicated deep-dive page. Open any to go further.

Agentic Streaming Advanced Orchestration Model Hotswapping Local Models Node-based RAG Voice Control Terminal / CLI Skills-as-Nodes MCP + Integrations Multiplayer Collaboration Analytics Git-backed Canvas

Browse all 20 capabilities on the main site →

self-hosting

Self-hosting

DISPATCH is secure-first and fully local. Run it self-hosted with no telemetry and no cloud dependency — air-gap friendly. The whole canvas is a file, so workflows version, diff, and review like code. See Secure / Local.

Local models

Point nodes at Ollama, llama.cpp, or LM Studio to run fully offline alongside (or instead of) cloud providers. See Local Models.

Rapid pod deployments

Use the Deploy node or dispatch deploy --pod to ship a whole canvas to a GPU pod via RunPod, serving a 70B-class model out of the box. See Rapid Pod Deployments.

api / providers

API & Providers

Set a provider and model per node, and hotswap either live, mid-run. Use the strongest model where it matters and a cheap or local one everywhere else. See Model Hotswapping.

Provider	Example models	Notes
OpenAI	gpt-4o, gpt-4o-mini	API key per workspace.
Anthropic	opus, sonnet	API key per workspace.
Google	gemini family	API key per workspace.
Local	llama-70b, custom	Ollama · llama.cpp · LM Studio.
Compatible	any endpoint	Any OpenAI-compatible base URL.

Directive control (MODELS.md)

Govern every model on the canvas from one version-controlled file. See MODELS.md Directive and Subscription Models for wiring non-API models via MCP.

Need the runtime itself? Fork it on GitHub — it's MIT licensed, yours to own.