I’ve been running Kandev on my dev box for a while. Jello asked me to compare it against Fusion — the newer, flashier entry in the agent-orchestration space. They share the same core idea (manage multiple AI coding agents from a dashboard) but the philosophy could not be more different.
Kandev — 547★ (Go, AGPL-3.0)
Links & Stats 👉 https://github.com/kdlbs/kandev
“Humans stay in control.”
Kandev is a developer IDE for agents. It gives you a kanban board, an integrated code editor with LSP, an embedded terminal, git diffs, and a browser preview — all in one web UI. You define tasks, assign agents, review their output, and approve what ships.
What it does well:
- Deep agent support — 20+ ACP agents out of the box (Claude Code, Codex, Copilot, Gemini, OpenCode, Hermes, Grok, etc.). Kandev doesn’t pin runtimes — it uses whatever version of each agent you have installed.
- Server-first architecture — local process, Docker, SSH, or Sprites cloud executors. The backend runs as a long-lived service you access from any device, including your phone.
- CLI passthrough — when you need the agent’s native TUI, drop into raw terminal mode. Best of both worlds.
- Git worktree isolation — every task gets its own branch and worktree. No file conflicts. Multi-repo tasks (one task spanning multiple repos) are supported natively.
- Agentic workflows — multi-step pipelines that mix agents per step. Opus to plan, Sonnet to implement, GPT-5.4 to review.
- Sub-tasks — agents can spawn sub-tasks that resume from the parent’s session. Useful when a task grows too big.
- Stats dashboard — task completion tracking, agent turn counts.
- External MCP — manage Kandev from outside agents over streamable HTTP or SSE, with ready-to-copy config snippets.
My take: Kandev is for developers who want to supervise agent work, not replace themselves. The integrated workspace (editor, terminal, git, browser in one view) is exactly what you need when you’re reviewing 10 parallel agent tasks. The review-first philosophy means you stay in the loop. AGPL-3.0 licensing means it’s free but commercial use needs consideration.
Fusion — 1,075★ (TypeScript, MIT)
Links & Stats 👉 https://github.com/Runfusion/Fusion
“From rough idea to production code — automatically.”
Fusion is an automated software factory. You describe what you want. A planning agent writes a full spec (PROMPT.md). Then Fusion plans, executes, reviews, and merges — optionally without you touching anything.
What it does well:
- AI planning — describe a task in plain language. The planner writes steps, file scope, and acceptance criteria before any code is written.
- Selectable workflows — 7+ built-in workflow graphs (coding, quick-fix, review-heavy, stepwise, PR lifecycle, compound engineering). Visually author custom ones in the Workflow Editor. This is genuinely novel — no other orchestrator lets you drag-and-drop workflow columns, gates, model lanes, and review policies.
- PostgreSQL default — zero-config embedded PostgreSQL for local metadata. Shared external PG for multi-node deployments.
- Multi-node mesh — laptop, Mac mini, Linux server, cloud VM, phone — all synced. Native iOS and Android apps (Capacitor + PWA).
- Agent companies — 440+ pre-built agents across 16 companies. Import a team, run it autonomously for weeks. Inter-agent mailbox, chat rooms, delegation.
- Command Center — fleet telemetry: live concurrency gauges, token spend by model, productivity metrics, agent org charts, anomaly detection. 70+ color themes.
- Planner oversight — per-task oversight level (
off/observe/steer/autonomous). Even at full autonomy, destructive actions require human confirmation. - Research runs — bounded research with web search, GitHub, local docs, and LLM synthesis. Turn findings into tasks.
- Missions — hierarchical planning (Mission → Milestone → Slice → Feature → Task) with autopilot and validation contracts.
- Self-improvement — agents reflect on their output and update their prompts as they learn your codebase.
- Hermes plugin — experimental plugin to run agents through Hermes for long-running, context-growing work. Paperclip and OpenClaw support too.
My take: Fusion is where Kandev wants to be in 12 months — if you buy the premise that agents should be autonomous and humans should only step in for exceptions. The Command Center is genuinely impressive: live token tracking, productivity charts, anomaly detection. 70 color themes is absurd over-engineering but tells you the team cares about polish. The MIT license is a big differentiator for commercial teams.
Head to Head
Philosophy — Review-first, human-in-the-loop (Kandev) vs Automate-first, human-as-exception (Fusion) License — AGPL-3.0 (Kandev) vs MIT (Fusion) Stack — Go backend, React frontend (Kandev) vs TypeScript/Node pnpm monorepo (Fusion) Storage — SQLite (Kandev) vs PostgreSQL embedded or external (Fusion) Agent count — 20+ ACP agents (Kandev) vs 440+ via agent companies (Fusion) Workflows — YAML-defined multi-step (Kandev) vs Visual Workflow Editor + built-in graphs (Fusion) Remote exec — Local, Docker, SSH, Sprites (Kandev) vs Mesh: all nodes are peers (Fusion) Mobile — Responsive web only (Kandev) vs Native iOS/Android + PWA (Fusion) Fleet telemetry — Basic task stats (Kandev) vs Full Command Center (Fusion) Inter-agent comms — Task-to-task MCP (Kandev) vs Full mailbox + chat rooms (Fusion) Self-improvement — No (Kandev) vs Yes, agent reflects and updates prompts (Fusion) CLI/TUI support — Native passthrough (Kandev) vs Agent chat + task chat only (Fusion) Git isolation — Worktrees, multi-repo (Kandev) vs Worktrees, single-repo per task (Fusion) Planning — Manual task description (Kandev) vs AI-generated PROMPT.md (Fusion) Maturity — ~8 months, stable (Kandev) vs ~4 months, early preview (Fusion) Stars — 547 (Kandev) vs 1,075 (Fusion)
Where Kandev Wins
- CLI passthrough — when you need the agent’s raw TUI, Kandev gives it to you. Fusion only supports chat interaction. For power users who want direct terminal access, this matters.
- Multi-repo tasks — one task across multiple repos, one worktree per repo, per-repo PRs. Fusion is single-repo per task.
- Maturity — Kandev has been in development since January 2026, has fewer open issues per star, and feels more stable. The ACP integration is battle-tested.
- External MCP — you can manage Kandev from outside agents. Fusion’s mesh is peer-to-peer within its own ecosystem.
- Sub-tasks — agents spawning child tasks from within a session is a Kandev-only feature.
Where Fusion Wins
- Autonomy — if you want to describe a feature and come back to a merged PR, Fusion is the only choice. The planner oversight levels let you dial autonomy from “watch everything” to “ship it.”
- Visual Workflow Editor — drag-and-drop workflow graphs are a killer feature. Kandev workflows are YAML files.
- Agent companies — 440+ pre-built agents across 16 companies, pre-wired for inter-agent coordination. This is a massive ecosystem advantage.
- Command Center — real-time fleet telemetry, token tracking, productivity analytics. Kandev has basic task stats.
- Multi-node mesh — every node is a peer; state syncs across devices. Kandev’s remote executors are workers, not peers.
- Self-improvement — agents that reflect on their output and update their prompts is a genuinely new capability.
- MIT license — no friction for commercial adoption.
The Verdict
These two tools are on diverging trajectories from the same starting point.
Kandev is for the developer who wants to direct an orchestra. You define the work, assign the musicians, listen to each section, and wave the baton. The integrated workspace (editor + terminal + git + browser) is designed for someone who spends their day reviewing code and wants AI to handle the grunt work.
Fusion is for the developer who wants to hire a contractor. Tell it what you want, it comes back with a finished artifact. The human steps in only when something goes wrong or when a destructive action needs approval. The Command Center exists to prove the contractor isn’t wasting your budget.
If you’re like me — you trust agents as far as you can throw them and want to review every diff — Kandev is the tool. If you’re running a team that needs to ship fast and trusts the pipeline, Fusion’s autonomy is compelling.
The real winner? Both. They’re complementary. I could see a workflow where Kandev handles the review-intensive, human-supervised work while Fusion runs the autonomous background tasks. The ACP ecosystem means they don’t have to be competitors — they can be peers on the same mesh.