Noureddine RAMDI / Fusion: orchestrating AI agents with git worktree isolation and multi-node synchronization

Created Sat, 23 May 2026 20:41:14 +0000 Modified Sat, 23 May 2026 20:41:27 +0000
921 Words
github-stars typescript ai-agent orchestration git-worktree multi-node electron

Runfusion/Fusion

Fusion is a multi-node agent orchestrator designed to transform rough task descriptions into production-ready code through autonomous AI planning agents. Unlike typical AI assistants that work in a single environment, Fusion isolates every task into its own git worktree branch, enabling multiple agents to run truly in parallel without file conflicts. This architecture allows laptops, servers, and phones to sync work seamlessly in a peer-to-peer mesh.

what Fusion does and how it works

At its core, Fusion orchestrates AI agents working on software development tasks by creating isolated execution contexts using git worktrees. Each task gets a dedicated branch under the fusion/{task-id} namespace, and a corresponding git worktree is checked out. This means agents operate on separate snapshots of the codebase, eliminating merge conflicts and allowing safe parallel edits.

The system implements a plan-review-execute-review workflow, where AI agents generate plans, execute them, and then await human approval at configurable checkpoints before moving forward. This gatekeeping balances autonomy with control, avoiding runaway or erroneous code changes.

Fusion supports over 440 pre-built agents spanning 16 companies, showcasing a broad catalog of agent capabilities. It is agnostic to language model providers, integrating with Anthropic, OpenAI, Ollama, and more. The project ships as a desktop app (Electron), mobile app (Capacitor), a web dashboard, and a CLI. All these clients synchronize state through a peer-to-peer multi-node mesh network managed by a background daemon.

Under the hood, Fusion also experiments with runtime plugins like Hermes, Paperclip, and OpenClaw, indicating a modular architecture that can extend core capabilities.

technical strengths and design tradeoffs

The standout technical feature of Fusion is its use of git worktree isolation for parallel AI task execution. Most multi-agent systems struggle with concurrency issues when agents edit shared files. Fusion sidesteps this by giving each task its own isolated branch and worktree. This approach leverages mature git internals instead of inventing a bespoke concurrency control system.

This design brings several benefits:

  • True parallelism: Agents run simultaneously without waiting on locks or coordination mechanisms.
  • Reduced merge conflicts: Since each agent works in isolation, conflicts only arise when branches are merged intentionally.
  • Auditability: Git history naturally tracks all agent changes per task.

However, there are tradeoffs:

  • Git complexity: The system depends heavily on git knowledge and infrastructure. Understanding worktrees and branch management is essential.
  • Overhead: Creating and managing many git worktrees and branches might impact performance at scale.
  • Merge effort: Eventually, isolated branches must be merged back, which can reintroduce conflicts if agents’ results overlap.

The multi-node mesh synchronization is another technical highlight. By syncing desktop, mobile, web, and CLI clients as peers, Fusion enables flexible usage scenarios where users can interact with agents from any device. This peer-to-peer model reduces reliance on central servers and supports offline-first workflows.

The codebase written in TypeScript spans frontend and backend concerns, with Electron and Capacitor enabling cross-platform deployment. The CLI offers scripting and automation capabilities, making Fusion adaptable to many environments.

quick start with Fusion

Fusion provides multiple straightforward installation paths, reflecting a focus on developer convenience.

Zero install, straight from npm:

npx runfusion.ai

This launches the dashboard with access to agent orchestration features. Subcommands work through npx runfusion.ai task create "fix X" or npx runfusion.ai --help.

One-line installer for macOS & Linux:

curl -fsSL https://runfusion.ai/install.sh | sh
fusion dashboard

This script auto-selects Homebrew or npm for installation, then launches the dashboard.

Homebrew (macOS & Linux):

brew tap runfusion/fusion
brew install fusion
fusion dashboard

Or install in one line with brew install runfusion/fusion/fusion.

npm global install:

npm install -g @runfusion/fusion
fn dashboard

From source clone for development:

pnpm dev dashboard

This runs the development server and opens the dashboard URL with authentication tokens managed automatically.

The first-run setup includes an onboarding wizard guiding AI provider configuration and optional GitHub integration for issue tracking.

verdict: who should use Fusion?

Fusion targets engineers and teams who want to orchestrate complex AI-driven software development workflows across multiple devices and nodes. Its git worktree isolation model solves a real concurrency problem in multi-agent code generation, making it relevant for projects where parallel AI tasks must run without interfering.

That said, Fusion’s reliance on git internals, multi-node mesh syncing, and complex workflow management means it has a learning curve and infrastructure overhead. It’s less suited for casual users or simple single-agent workflows.

If you’re building autonomous AI coding agents or coordinating multiple AI workflows that need auditability and safe parallelism, Fusion offers a robust foundation with practical multi-platform clients and integrations.

The project is actively maintained, MIT-licensed, and designed for real-world multi-week autonomous agent runs — an ambitious but thoughtfully engineered approach to AI orchestration.

→ GitHub Repo: Runfusion/Fusion ⭐ 607 · TypeScript