Orchestrate your coding agents.Debug them like code.
Wire Claude Code, Codex and any API model into one visual pipeline. Every run lands as plain files you can grep, diff, and replay.
Instant access, no waitlist · Free in early access · Your keys, zero token markup · Runs are plain files on your machine
The canvas is a web UI — execution and artifacts stay in .futsu/ on your machine. Cloud runs are opt-in.
Runs the agents and models you already use
Every run is a folder. Not a mystery.
Each pipeline run persists to .futsu/runs/as plain files — the full event stream, every node's output, the final state. Debug your agents with the tools you already trust: grep, diff, git.
- Live PTY stream from every node while it runs
- state.json + events.ndjson on disk — git-diffable and replayable
- Replay any historical run, step by step
Don't take our word for it — grep it before you sign up:
$ cd .futsu/runs/8f3a21
$ jq -c 'select(.type=="step.completed") | {id,node_id}' events.ndjson
{"id":5,"node_id":"plan"}
{"id":11,"node_id":"claude-code"}
{"id":12,"node_id":"codex"}
{"id":14,"node_id":"review"}
$ futsu diff 7d201c 8f3a21
- "model": "claude-sonnet-4-6"
+ "model": "claude-fable-5"
2 nodes changed · 1 retry · −38% cost
$
Six pieces. One pipeline.
Everything an agent pipeline needs — and nothing you can't switch away from in a click.
One canvas. The whole pipeline.
Compose agents, models, conditions and human gates as a graph on a pure-FSM engine — no YAML, no glue scripts.
- Branch, merge and parallel fan-out
- N8N-style arrow edges show data flow
- Replay any historical run on the graph
Claude, Codex & OpenAI. One graph.
Futsu spawns real CLI coding-agent sessions and API calls as pipeline nodes and streams every PTY character live.
- Real claude / codex sessions as nodes
- Per-node model, temperature, max-tokens
- Cancel, retry and resume mid-run
$ futsu run release.canvas --watch
▸ node plan claude @smart
✓ 4 tasks planned · 3.3k tok
▸ node claude-code PTY live
tool Edit src/api/auth.ts ✓
▸ node codex PTY live
tool Bash pnpm test ✓ 41 passed
review waiting on 2 branches
Agents you can git blame.
Personas and skills are markdown files in .claude/ — reviewed in pull requests, versioned next to the code they operate on.
- Sourced from .claude/{agents,skills}
- Frontmatter: model, tools, persona
- No registry, no lock-in — plain files
.claude/
├─ agents/
│ ├─ architect.md
│ ├─ reviewer.md ← model: opus · tools: [Read, Grep]
│ └─ debugger.md
└─ skills/
├─ deep-research/
└─ release-notes/
✓ loaded 3 agents · 2 skills — versioned with the repo
Edit in Obsidian. Run in Futsu.
Futsu speaks JSON Canvas v1.0 with lossless round-trips — the same .canvas file opens in both tools, and git diff proves it.
- Open JSON Canvas v1.0 format
- Round-trip preserves unknown fields
- Pipelines live in your vault as files
$ git diff release.canvas
+ {"id":"n7","type":"text",
+ "text":"review @fast"}
edges: 6 → 7
# edited in Obsidian — runs in Futsu
✓ round-trip lossless, unknown fields preserved
Plaintext, nowhere.
API keys live as AES-256-GCM ciphertext, scoped to you or your workspace, decrypted only in memory when a run needs them.
- AES-256-GCM at rest, hydrated per run
- User and workspace scopes
- Scan a repo, import leaked keys in one click
Zero markup. Hard caps.
Bring your own keys and pay providers directly; set a ceiling per run, project or workspace and watch a runaway pipeline halt.
- BYOK — Futsu never resells a token
- Caps enforced mid-run, not flagged later
- Live per-node cost metering
Built different, provably.
Not just screenshots — artifacts you can verify the moment you install it.
Coding agents as nodes. Wired, not listed.
Futsu runs real Claude Code and Codex CLI sessions as pipeline nodes — branch them in parallel, pipe one agent's output into the next, gate releases behind a human checkpoint. Task boards manage agents; Futsu connects them.
plan ──▶ claude-code ──▶ review ──▶ [HOLD] checkpoint
└─▶ codex ───────────┘ └─▶ shipLeave any afternoon. It's all plain files.
Canvases, runs, agents and skills live on your disk in open formats. No export button needed — there is nothing to export.
.futsu/runs/8f3a21/state.json .futsu/runs/8f3a21/events.ndjson .futsu/prompts/review.md .claude/skills/release-notes/
AES-GCM vault. Plaintext, never at rest.
Ciphertext lives in your local vault, scoped to you or your workspace, decrypted only at runtime — and the master key is never stored beside the data. Tools in this category have leaked stored API keys before; plaintext that isn't stored can't leak.
Hard cost caps. Enforced, not suggested.
Set a ceiling per run, workflow, project or workspace. When a pipeline hits it, the run halts — your margin survives the retry loop.
Obsidian sync. Diff it yourself.
Futsu speaks JSON Canvas v1.0 with round-trip preservation. Edit in Obsidian, run in Futsu — and verify the sync with a plain git diff.
$ git diff release.canvas
+ {"id":"n7","type":"text",
+ "text":"review @fast"}
edges: 6 → 7Three steps to your first run.
Draw the graph
Open a canvas and drop nodes — models, CLI agents, conditions, human checkpoints. The graph is the program.
Pin models & keys
Attach an instruction and a model to each node — or an alias like @smart. Keys come from your encrypted vault.
Run & watch
Hit run and watch every node stream live. Then grep the artifacts, diff the runs, and iterate.
Free in early access. Your keys, zero markup.
Bring your own API keys and pay providers directly — Futsu never marks up a token. Optional managed token credits exist for teams that don't want to handle keys.
I run coding agents all day, and I was tired of babysitting five terminals with no pipeline between them. Futsu is the canvas I wanted: agents wired together, every run a folder I can grep. It's early — the canvas, runners, live streaming, the vault and cost caps work today; SSO and SLAs don't exist yet. If you try it and something breaks, tell me. That's what early access is for.
— Dmitry, building Futsu · hello@futsu.cloud
Frequently asked.
API runners for Claude and OpenAI, plus real CLI coding agents — Futsu spawns your locally installed claude (Claude Code) and codex sessions as pipeline nodes. You can pin a different model or agent to every node in a single pipeline.
n8n and Langflow wire API calls; Futsu also runs real CLI coding agents (Claude Code, Codex) as nodes with live PTY streams. LangGraph is a code framework — Futsu is the canvas on top. And agent task boards manage parallel sessions as a list; Futsu pipes one agent's output into the next on a wired graph, with retries, branches and human gates.
Because the published evidence says self-review is the weak link: models struggle to correct their own output without external feedback, evaluators measurably favor their own generations, and feedback from a different model outperforms self-generated feedback on code repair. Futsu makes the fix a one-edge change — wire the writer into an independent reviewer on another model, give it the test output, and keep the final gate human. WP-001We wrote up the evidence — 15 sources
Instant. Sign up, open a canvas, and run your first pipeline in the same sitting — no invite queue, no sales call. Early access simply means the product is young and we say so.
In an AES-GCM encrypted vault, scoped to you or your workspace, decrypted only at runtime. Ciphertext stays in your local store; the master key is never written beside the data, and plaintext is never persisted anywhere.
Hard cost caps are enforced per run, workflow, project and workspace. A run that hits its cap is halted mid-pipeline — not flagged in a dashboard the next morning. And with bring-your-own-keys, Futsu adds zero markup on top of provider prices.
Runs execute locally and every artifact persists as plain files under .futsu/runs/ — state, events, per-node output. You can grep them, diff them, commit them, or delete them. Cloud execution is opt-in.
Yes — Futsu implements JSON Canvas v1.0 with round-trip preservation: open the same .canvas file in either tool, edit in one, and verify the change in the other with a git diff. Unknown fields are preserved, not dropped.
You lose a UI, not your work. Canvases are JSON Canvas v1.0 files Obsidian can open; runs are state.json + events.ndjsonon your disk; prompts and skills are markdown. Every format outlives us by design — that's the point of plain files.
Honest answer: the file formats are open standards (JSON Canvas v1.0, plain JSON/NDJSON — a spec README ships inside every sample run folder), and execution is local-first: runs execute on your machine and the artifacts never depend on futsu.cloud being up. The engine itself is proprietary during early access while we finalize the long-term license — that decision lands before we charge anyone a dollar. If the license question matters to you, it matters to us: write to us.
Futsu is in early access. The canvas, the multi-runner engine, PTY streaming, the vault and cost caps are live today; SSO and SLAs are not. It's free while we earn the right to charge you — early users shape what ships next.
Wire your first pipeline tonight.
Draw the graph, pin your agents, hit run — and grep the artifacts when it's done. Free in early access, no credit card.
Instant access, no waitlist — or download a real run folder first.