Canvas Planning
Plan the work before you build it. Shape goals, phases, milestones, and risks on a planning canvas — then turn the plan into a runnable chain.
A plan-mode that lives on the same graph.
Lay out a Goal, split it into Phases, mark the Milestones that prove each phase landed, and flag the Risks that could derail it — as square cards on the same canvas you build chains on.
The plan is the graph — no separate doc, no throwaway whiteboard. When the shape feels right, DISPATCH compiles it into typed nodes — Plan, Investigate, Create, Review, Deploy — wired top-to-bottom and ready to Run.
Shape a plan, then compile it.
Place planning cards — Goal, Phase, Milestone, Risk — then compile them into a runnable chain and watch it wire itself.
Pick a card type above, then press Place card.
Compile the plan to wire it into a runnable chain of DISPATCH nodes.
Non-destructive — compiling lays the chain beside the plan, never over it. Refine either side, recompile any time.
Four card types. One compiler.
Each planning card carries intent. The compiler reads that intent and emits the right DISPATCH node — with edges, context keys, and gates already in place.
The single outcome you're driving to.
One Goal card anchors the plan. The compiler turns it into the Initialiser + a Plan node that holds the brief and writes it to run.plan for every downstream node to read.
A unit of work, in order.
Each Phase becomes one or more execution nodes — Investigate, Design, Create — wired top-to-bottom in the order you placed them. Phases can fan out with Parallel and reconverge with Merge.
Proof a phase actually landed.
A Milestone compiles to a Review or Evaluate gate. The chain pauses there until the milestone's condition is met — a human checkpoint, or an automated assertion on the upstream output.
The thing that could go wrong.
A Risk card attaches a mitigation to the phase it threatens — a retry policy, a timeout, a fallback branch, or an extra Investigate step. It surfaces in the compiled chain as guardrails, not surprises.
Compiling reads the plan top-to-bottom and emits a deterministic graph — a normal DISPATCH chain, every node hotswappable, every edge live. Keep editing on the canvas after it compiles.
Cheaper mistakes happen on the plan, not the run.
-
Catch structure before you spend tokens. A wrongly-shaped chain burns API spend every run. Fixing a misordered phase on the plan costs nothing.
-
Intent is reviewable. Goals, phases and risks read at a glance — a teammate can comment on the plan over the LAN before a single node fires.
-
Risks become guardrails, not incidents. Naming what could break up front means the chain ships with retries and gates exactly where they belong.
Pairs well with
Advanced Orchestration
Branch, retry, cap concurrency, loop, nest, gate, timeout — the controls a compiled plan emits.
openAgentic Streaming
Fan a planned phase out across 20 agents — parallel, streamed, synthesized.
openGit-backed Canvas
Your plan is a file too — commit, diff, and review it like code.
openPlan it once.
Run it for real.
Canvas Planning is landing soon. It's MIT — follow along or jump in, every contribution moves it forward.