Maestro: Running Six AI Coding Assistants in Parallel Without Losing Your Mind

Hook

What if the slowest part of AI-assisted development isn't the AI—it's you, waiting for it to finish one task before starting the next? Maestro lets you spawn six Claude or Gemini sessions in parallel, each working on separate features in isolated git worktrees.

Context

AI coding assistants like Claude Code and GitHub Copilot have transformed how we write code, but they've introduced a new bottleneck: serial execution. You prompt the AI, wait 30-90 seconds for it to generate code, review the changes, then move to the next task. For developers juggling multiple features, bug fixes, or refactoring efforts, this becomes a game of context-switching hell. You can't efficiently work on feature A while the AI handles feature B because most tools assume single-session workflows.

Maestro emerged from this frustration, positioning itself as "The Bloomberg Terminal for CLI Agents." Just as Bloomberg terminals let financial professionals monitor multiple data streams simultaneously, Maestro provides a dashboard for running multiple AI coding sessions in parallel. Instead of waiting for Claude to finish implementing authentication before starting on the API endpoints, you spawn two sessions and let both AIs work concurrently. The core innovation isn't better AI—it's better orchestration of existing AI tools through git worktrees, process management, and the Model Context Protocol.

Technical Insight

Maestro's architecture solves a deceptively complex problem: how do you let multiple AI agents modify the same codebase without conflicts? The answer lies in git worktrees, a lesser-known git feature that creates multiple working directories from a single repository. When you launch a Maestro session, it doesn't just open a terminal—it creates a new worktree under ~/.claude-maestro/worktrees/, checks out a feature branch, and spawns your AI CLI tool in that isolated environment.

The Rust backend's ProcessManager handles the heavy lifting. Each session gets a PTY (pseudo-terminal) that captures stdout/stderr, which gets piped to xterm.js in the React frontend. Here's what the worktree creation flow looks like in simplified form:

// When a new session starts, Maestro creates an isolated workspace
async function createSession(sessionId: string, taskDescription: string) {
  const branchName = `maestro/${sessionId}`;
  const worktreePath = `~/.claude-maestro/worktrees/${sessionId}`;
  
  // Create a new git worktree with its own branch
  await git.worktree.add(worktreePath, branchName);
  
  // Spawn the AI CLI tool in that worktree
  const process = spawn('claude-code', [taskDescription], {
    cwd: worktreePath,
    env: { ...process.env, MAESTRO_SESSION: sessionId }
  });
  
  // Attach MCP server for status reporting
  await mcpServer.attachToSession(sessionId, process);
}

The MCP (Model Context Protocol) integration is what elevates Maestro from a fancy tmux wrapper to an actual orchestration platform. MCP is an open protocol that lets AI agents communicate structured information back to their environment. Maestro ships with a built-in MCP server that AI agents can call to report their status: idle, working, needs_input, finished, or error. This creates a feedback loop where the dashboard updates in real-time based on what each AI is actually doing.

The protocol works through a simple JSON-RPC interface that AI agents can invoke via CLI commands or API calls. When Claude Code hits an error or needs user input, it can call the MCP endpoint, and Maestro surfaces that in the UI with a notification. This is far more sophisticated than parsing terminal output—you get semantic status updates that drive UI state.

The Tauri 2.0 foundation matters more than you might think. Tauri bundles Rust backend code with a web frontend, but unlike Electron, it uses the system's native webview instead of bundling Chromium. The result is a ~15MB binary instead of 150MB+ for equivalent Electron apps. More importantly, Rust's async runtime handles dozens of concurrent PTY streams without breaking a sweat, which is critical when you're multiplexing six terminal sessions with real-time output.

The plugin architecture extends beyond just AI providers. Maestro supports three plugin types: skills (reusable prompt templates), commands (custom CLI tools), and MCP servers (status reporters). You could write a custom MCP server that reports test coverage changes, or a skill that generates API documentation in your company's style. The marketplace is community-driven, hosted on GitHub, and installed via npm—no proprietary app store.

One underappreciated aspect is how Maestro handles git operations. Because each session runs in its own worktree, you can have six AIs committing to six different branches simultaneously without conflicts. When a session finishes, you review the changes in that specific worktree and merge the branch back to main. This isn't just convenient—it's the only practical way to do parallel AI development without constant rebase hell.

Gotcha

Maestro assumes you're already bought into the AI CLI tool ecosystem, and that setup tax is non-trivial. You need to install and configure each AI provider separately—Claude Code requires API keys and setup scripts, Gemini CLI needs authentication, and each has its own quirks. Maestro doesn't abstract these differences; it orchestrates tools you've already configured. If you're new to AI coding assistants, the learning curve is steep because you're learning both Maestro and the underlying AI CLIs simultaneously.

The git worktree model also has sharp edges. Worktrees share the same git object database but have separate working directories, which means some git operations behave counterintuitively. If you delete a worktree directory without running git worktree remove, you'll leave stale metadata. If two sessions try to checkout the same branch (which Maestro prevents, but custom scripts might not), you'll get cryptic errors. The six-session limit is hardcoded, presumably to prevent resource exhaustion, but there's no graceful handling if you need more parallelism. And if your project uses submodules or git-lfs, expect additional configuration overhead that Maestro doesn't document well. This tool works beautifully for standard git workflows but requires git expertise to troubleshoot when things go wrong.

Verdict

Use if: You're already using AI CLI tools like Claude Code or Gemini CLI and find yourself waiting on AI responses before starting the next task. You're comfortable with git worktrees and feature branch workflows. You work on projects with multiple independent tasks that can be parallelized—like a web app where you're simultaneously building API endpoints, writing tests, and refactoring components. You value the visual dashboard for monitoring multiple AI sessions and want MCP-based status reporting. Skip if: You're new to AI coding assistants and want an all-in-one solution—start with Cursor or GitHub Copilot in your IDE instead. Your project structure doesn't align with feature branches (monorepos with tight coupling, or single-branch workflows). You prefer IDE-integrated AI over terminal-based tools. You need more than six parallel sessions or require enterprise features like team collaboration or centralized logging. Maestro is a power tool for developers who've outgrown single-session AI assistants, not a beginner-friendly entry point.