The Complete Guide to CrewCode: The Control Center for Multi-Agent Software Development

TL;DR: CrewCode is a free, open-source desktop ACE (Agent Coding Environment) that puts multiple AI coding agents - Claude Code, Codex, OpenCode, and more - into a single supervised window with isolated git worktrees, real terminals, and a built-in code editor. As 90% of professional developers now use AI coding agents weekly, CrewCode solves the chaos of juggling terminals, worktrees, and PR tabs by keeping the full workflow in one place. The AI coding agent market is projected to grow from $10.4 billion in 2025 to $149.6 billion by 2034 at a 39.5% CAGR.

Table of Contents

Introduction

As of mid-2026, roughly 90% of professional developers use AI coding agents at work at least weekly, with 68% relying on them daily. But the tools for managing those agents haven't kept pace - developers still juggle fragmented terminals, scattered worktrees, and browser tabs across multiple platforms. CrewCode was built to fix that gap.

CrewCode is a free, open-source desktop application that gives developers a single, supervised window for running multiple AI coding agents in parallel. It integrates chat, real terminals, a code editor, and isolated git worktrees so each agent works on its own branch without conflicts. Developers can mix providers like Claude Code, Codex, OpenCode, Pi, Ollama, and Grok Build, switch models inline, and manage approvals through a built-in Mission Control dashboard.

This guide covers what CrewCode does, the pain point it was built to solve, why the creator built it, and how it works under the hood - from worktree isolation to agent orchestration, plugin architecture, and cross-device continuity via the Background Brain.

CrewCode is built by Cj from OnPoint Tools, an independent developer tooling company. The app targets macOS, Linux, and Windows, and is released under the Apache 2.0 license. It is used by solo developers, technical founders, and small engineering teams who need to supervise parallel agent workflows without losing control of their repository.

The global AI-powered software development agent market was valued at $10.4 billion in 2025 and is projected to reach $149.6 billion by 2034, expanding at a CAGR of 39.5%. (Source: MarketIntelo, 2026)

What Is CrewCode?

CrewCode is a desktop Agent Coding Environment (ACE) - a unified application that combines chat interfaces, real terminals, a code editor, and git worktree management into a single window for developers who run multiple AI coding agents.

Unlike browser-based AI coding tools that live inside a single IDE tab, CrewCode is a standalone desktop application built with Electron, React, and TypeScript. It runs multiple agent sessions simultaneously, each in its own isolated git worktree, so agents don't step on each other's changes. It supports structured agent bridges and PTY-backed terminals depending on the provider, and it lets developers mix providers mid-session with automatic handoff summaries.

Key components include:

  • Multi-provider agent support: Claude Code, Codex, OpenCode, Pi, Ollama, Hermes, OpenRouter, Grok Build, and CrewCoder
  • Git worktree isolation: Each agent gets its own branch and working directory
  • Mission Control: A dashboard for supervising active agents across projects
  • Code Editor: Language-aware editor with LSP support, themes, and AI completions
  • Plugin platform: Local-first extension system with sandboxed panels and MCP server declarations
  • Desktop & Web Continuity: Background Brain for picking up work from any browser
  • Realtime voice: Provider-neutral voice layer for talking with coding agents

Anthropic's 2026 Agentic Coding Trends Report found that while developers use AI in roughly 60% of their work, they report being able to "fully delegate" only 0–20% of tasks - the rest requires active supervision and validation. CrewCode is designed for exactly this pattern: agents that work autonomously but under human oversight.

The orchestration layer — launching crews, configuring lanes, and supervising runs — is covered in depth below (Crew orchestration docs).

The Pain Point: Why Multi-Agent Development Is a Mess

As soon as you run more than one coding agent, the workflow gets messy fast: too many terminals, too many worktrees, too many half-finished diffs, and not enough visibility into what each agent is doing.

The problem isn't AI coding agents themselves - they're remarkably capable. The problem is the infrastructure around them. When a developer runs Claude Code on one terminal, Codex on another, and CrewCoder on a third, they face a cascade of coordination failures:

  1. Terminal sprawl: Each agent gets its own terminal window or tab. Keeping track of which agent is doing what requires switching between multiple terminal sessions. There is no unified view of all active agents.
  2. Worktree conflicts: Without isolation, agents editing the same files create merge conflicts constantly. Developers end up stashing changes, juggling branches, and manually resolving conflicts that should have been prevented.
  3. Diff fragmentation: Half-finished changes accumulate across multiple branches and worktrees. Reviewing what each agent actually changed becomes a time-consuming archaeological exercise.
  4. Browser and PR tab overload: When agents finish work, developers switch to browser tabs to review PRs, merge branches, and update issue trackers. The context-switching cost compounds with every agent and every task.
  5. Zero visibility: Without a central dashboard, developers cannot see at a glance which agents are running, which are blocked, which need attention, or what each one is working on. The supervisor is blind until they manually check each session.
  6. No memory continuity: When an agent session ends - whether from a crash, a model switch, or a manual stop - the conversation context is often lost. Starting a new session means starting from scratch, re-explaining the codebase, the task, and the constraints.

Stack Overflow's 2025 Developer Survey found that trust in AI code output dropped to 29% in 2025, down from 40% in 2024 - even as adoption rose to 84%. The trust gap makes supervision non-negotiable: developers need to see what their agents are doing, not just hope the output is correct.

The real bottleneck in multi-agent development is not agent capability - it's the coordination overhead. Research from Keyhole Software (2026) shows that only ~13% of teams have AI operating across the full SDLC, and only ~22% have deployed true AI coding agents. The gap between "agents exist" and "agents are manageable" is where CrewCode operates.

The Multi-Agent Systems market is projected to expand from $11.5 billion in 2026 to $78.5 billion by 2031 at a CAGR of 46.76%. But market size doesn't solve the coordination problem - dedicated tools do.

Why CrewCode Was Created

CrewCode was created because i needed a way to run and supervise multiple AI coding agents on real repos without losing control of the repository. Existing tools forced developers to choose between convenience and control. CrewCode delivers both.

The motivation was straightforward: as a developer working with multiple AI agents, the creator experienced the exact pain points described above. Terminals multiplied, worktrees collided, and visibility evaporated. Browser-based tools offered convenience but lacked the isolation and supervision that serious multi-agent work demands. Existing desktop tools were either single-agent only or lacked the git-native workflow that makes parallel development safe.

The core insight was this: multi-agent development isn't just about running more agents - it's about supervising them in a way that keeps the repo clean, the diffs inspectable, and the human in control. That requires a desktop application that treats git worktrees as first-class citizens, that gives agents their own isolated environments, and that surfaces all agent activity in a single dashboard.

CrewCode was also built with a specific philosophy: local-first, open-source, and provider-agnostic. The creator wanted a tool that doesn't lock developers into a single AI provider, that keeps code and transcripts local by default, and that can be extended through plugins rather than being a closed platform.

The AI coding agent platform market is projected to reach $175.4 billion by 2034 at a CAGR of 38.7%. But the market's trajectory toward multi-agent orchestration - where specialized agents handle planning, coding, review, testing, and deployment as coordinated roles - is exactly the problem CrewCode was built to solve. The shift from single-agent assistants to orchestrated agent teams is the core thesis behind the project.

Anthropic's 2026 report identified multi-agent systems as the defining trend for the year: "Organizations adopt multi-agent workflows that maximize performance gains through parallel reasoning across separate context windows." CrewCode's architecture - isolated worktrees, lane-based orchestration, and crew templates - maps directly to this trend, making it a practical implementation of the multi-agent thesis for individual developers and small teams.

What CrewCode Does

Run Multiple Agents in One Workspace

CrewCode lets developers run multiple AI coding agents simultaneously from a single application window. Each session gets its own chat tab, model, mode, and effort level - and each runs in its own isolated git worktree so changes never conflict.

Supported providers include:

  • CrewCoder (via ACP bridge)
  • Claude Code
  • Codex
  • OpenCode
  • Pi
  • Ollama (local models)
  • Hermes
  • OpenRouter
  • Grok Build

Developers can switch providers mid-session, and CrewCode automatically creates a handoff summary so the new agent continues work without losing context. Persistent sessions can be resumed instead of starting from scratch every time.

Claude Code's adoption grew from ~3% in early 2025 to 39% globally by mid-2026 - a 13x increase. CrewCode supports this rapid rotation of providers by letting developers switch models and agents without changing tools. (Source: JetBrains Developer Ecosystem Survey 2026)

Worktree-Native Development

At the heart of CrewCode is git worktree isolation. Every agent session runs in its own worktree - its own branch and working directory - so parallel work never collides.

Developers can:

  • Add existing repos or folders
  • Clone repos directly into a local workspace
  • Initialize new projects from scratch
  • Create, switch, merge, and remove git worktrees inside the app
  • Keep parallel work isolated without stashing or branch juggling
  • Surface exact file overlap and likely cross-file contract collisions before crew merges

This is not a nice-to-have feature. It is the architectural foundation that makes multi-agent development possible without the repository becoming a mess of conflicting branches and merge conflicts.

GitHub's autonomous agent data shows that coding agents opened over 1 million PRs between May and September 2025, reaching approximately 1.2 million autonomous PRs per month at run-rate. Without worktree isolation, that volume of parallel changes would be unmanageable.

Crew Orchestration and Supervision

CrewCode supports launching a crew of agents in parallel - a group of specialized agents each configured with different roles, models, and effort levels. Each lane in a crew runs independently and can be inspected, restarted, muted, rebroadcast to, or killed from the Mission Control dashboard.

Mission Control provides:

  • A unified dashboard showing active agents across all projects
  • Grouping by project, status, type, or worktree
  • Quick spotting of blocked runs
  • A live cross-app activity feed
  • Per-lane controls: restart, mute, rebroadcast, inspect

Crew templates can be saved and reused, so developers don't need to configure lanes from scratch for every project. Common patterns - like a "review lane" that checks every PR, or a "test lane" that runs regression tests in parallel - become one-click workflows.

Anthropic's 2026 Agentic Coding Trends Report identifies multi-agent coordination as the #1 priority for organizations planning their 2026 AI strategy, noting that "multi-agent systems replace single-agent workflows" as the dominant pattern.

Realtime Voice and Composer Dictation

CrewCode includes a provider-neutral realtime voice layer for talking naturally with the coding agent in the active chat. The voice orb supports GPT Realtime, xAI Voice, or fully local speech with NVIDIA Parakeet TDT 0.6B v2 for transcription and Kokoro-82M with the am_michael voice for speech synthesis.

The separate composer microphone handles speech-to-text only - inserting text at the caret for review before sending to the agent. This ensures that voice input is always verified before it becomes an instruction.

Local voice inference can run on Automatic, GPU, or CPU modes, with idle models unloading while the lightweight voice sidecar stays available. Provider API keys never enter renderer state - they live in Electron's main process, keeping credentials isolated.

Code Editor and Writer Workflow

CrewCode ships with a language-aware code editor featuring TypeScript/LSP completions, themes, document outline, TypeScript and JavaScript intelligence, a problems drawer, and code actions. The editor also supports the Writer workflow - a document editing mode for drafting and reviewing Markdown or plain-text documents alongside an agent chat.

The Writer workflow supports:

  • Converting DOCX and PDF files into editable Markdown working copies without overwriting originals
  • Detecting agent edits and reviewing them as Pierre text diffs before accepting or denying
  • Exporting approved working copies to collision-safe DOCX or PDF files

SonarSource's 2026 State of Code survey found that 42% of developers' code is currently AI-generated or assisted, up from 6% in 2023 - and developers predict this will increase by over half by 2027. The need for review tools grows proportionally with AI-generated code volume.

Local Plugin Platform

CrewCode includes a local-first plugin system for trusted developer automation. Plugins can add isolated panels, sidebar panels, status items, editor/chat actions, git lenses, browser actions, terminal watcher actions, MCP server declarations, and custom agent providers.

Plugin architecture highlights:

  • Plugin UIs are built as static HTML/JS assets loaded through crewcode-plugin:// sandboxed iframes
  • The typed crewcode-plugin-api browser package handles safe postMessage calls into CrewCode
  • Plugin agent providers support mock, exec, and http runtimes - connecting local CLIs or internal HTTP agent gateways without giving plugin UI direct Electron or Node access
  • Permissions can be approved, revoked, and toggled globally or per-workspace

The plugin platform supports MCP server declarations, aligning with the Model Context Protocol trend that Anthropic and other AI labs are driving for standardized agent-tool interoperability.

How CrewCode Works

Architecture Overview

CrewCode is built on three layers:

  1. Main Process (src/main/index.ts): The Electron main process that creates browser windows, handles IPC for window controls, and manages the plugin contract, security model, and execution custody system. This is where provider API keys live and where privileged operations are gated.
  2. Preload (src/preload/index.ts): Exposes window.electronAPI to the renderer via contextBridge, providing a typed bridge between the privileged Electron world and the React renderer.
  3. Renderer (src/renderer/src/): A React SPA that owns all UI state. There is no global state manager - everything flows through React useState. Components are organized by domain: thread, composer, terminal, editor, workspaces, and UI primitives.

The Execution Custody System

Every agent dispatch in CrewCode creates a dedicated activity transcript record for that turn. Raw PTY agents are excluded because their terminal outcome is not observable through the bridge. The activity lifecycle follows observed bridge events:

  • turn_start begins work
  • Tool categories may update the deterministic phase
  • Normal turn_end completes it
  • Prompt rejection, abort, stop, bridge error/closure, custody halt, or lost runtime becomes cancelled/interrupted - never success

This ensures that CrewCode's terminal outcome always wins over stale provider-native state. Provider-native todo/plan/task snapshots may replace the generic row only while the CrewCode lifecycle is active.

LinearB's 2026 benchmarks show that AI agent pull requests wait 17.6 hours before review versus 3.4 hours for unassisted work - a 5.25x gap. The custody system ensures that when an agent's work is interrupted, the state is preserved and recoverable, not silently lost.

Provider Context Handoff

CrewCode supports switching providers mid-session. When a developer switches from Claude Code to Codex (or any other provider), the system:

  1. Captures the current conversation state and worktree context
  2. Creates a handoff summary for the new agent
  3. Continues the session without leaving the chat or losing context

This is distinct from Crew Surface - crew lanes are ephemeral and exist only for the duration of a crew run. Delegated threads are ordinary Sessions with transcripts, archiving, and drawer rows that outlive the turn that made them.

Desktop & Web Continuity (Background Brain)

CrewCode can connect to a detached "Brain" - a background process that keeps workspaces, chat sessions, transcripts, terminals, and agents alive even after the Electron window closes. When the desktop app reopens, it syncs with the Brain and resumes exactly where it left off.

For cross-device access, a self-hosted crewcode hub provides a single passkey-secured dashboard of all enrolled machines. Brains connect outbound-only - no open inbound ports needed. The relay is end-to-end encrypted; the Hub never sees code, prompts, transcripts, or terminal output.

The global remote work management market is expanding rapidly, with 42% of leaders expecting teams to build multi-agent systems to automate complex tasks (Microsoft 2025 Work Trend Index). CrewCode's Background Brain architecture maps directly to this trend.

Security Model

CrewCode's security model follows a layered authority-boundary audit:

  • Untrusted content → Agent → MCP/Plugin → Exec → Git/SSH
  • Each hop has explicit gates and tests
  • Authority is granted per-operation and can be withdrawn
  • The custody journal records every authority mutation
  • If an invariant trips, the system halts, contains, preserves evidence, and reports the exact failed invariant

This model ensures that even when agents have broad capabilities, each action is checked against the current authority state, and any deviation is caught and reported.

With trust in AI code output dropping to 29% (down from 40% in 2024), a security model that can audit every agent action and withdraw authority on failure is not optional - it is essential. (Source: Stack Overflow Developer Survey 2025)

Advanced: Desktop & Web Continuity

CrewCode's Background Brain feature enables a workflow where developers can leave their PC running at home and pick up exactly where they left off from a browser - or run CrewCode headless on a VPS, NAS, or always-on server so agents are always reachable.

Setup involves:

  1. Running crewcode hub --local-brain on an always-on host
  2. Enrolling development machines with crewcode enroll --hub <url>
  3. Running crewcode brain on each machine
  4. Enabling Background Brain in Settings → Desktop & Web

The Brain store becomes authoritative for routed workspaces, transcripts, replay/resume state, terminals, agents, and the allowlisted workspace/chat catalogue. Seed only missing Brain state, preserve provider-specific resume keys, and alias legacy thread: replay to web: without overwriting existing Brain data.

This is a preview feature with documented first-release limits. Remote authority is off until explicit workspace roots and scopes are granted; pairing codes and connection tickets are short-lived and single-use; sign-in is passkey-based; provider API keys never leave the Brain's machine.

Getting Started

CrewCode is free and open-source under the Apache 2.0 license. To get started:

  1. Download the installer for your platform from crewcode.logixhub.icu. The Linux installer detects Arch-based and Debian-based distributions and uses their native package manager. Other x86_64 distributions receive a user-local AppImage installation.
  2. Verify the installer before running it. The installer verifies the release artifact with SHA-256 and prompts before invoking a package manager or writing application files. It refuses to run as root.
  3. Launch and add or clone a project. Create a worktree, start an agent session, and watch output in chat, terminal panes, and Mission Control.
  4. Inspect diffs, commit changes, open or merge PRs, or discard work - all from within the app.

Development mode:

npm run dev        # Start dev server (Vite renderer + Electron main)
npm run build      # Build all three processes via electron-vite
npm run preview    # Preview the production build
npm run typecheck  # Run tsc --noEmit across all tsconfigs

CrewCode is built with Electron, React, TypeScript, electron-vite, xterm, and node-pty - a stack that balances native performance with web developer familiarity.

FAQ

What is the difference between CrewCode and CrewCoder?

CrewCode is the desktop ACE application; CrewCoder is the AI agent that can run inside it via the ACP bridge. CrewCode includes first-class CrewCoder support, so you can run and supervise CrewCoder directly from the app and ask it to create custom CrewCode plugins tailored to your workflow.

Does CrewCode work on all platforms?

CrewCode targets macOS, Linux, and Windows. The Linux installer supports Arch-based and Debian-based distributions, with AppImage support for other x86_64 distributions.

Can I use my own AI providers?

Yes. CrewCode supports multiple providers out of the box - Claude Code, Codex, OpenCode, Pi, Ollama, Hermes, OpenRouter, Grok Build, and CrewCoder. You can also build custom agent providers through the plugin platform using mock, exec, or http runtimes.

How does CrewCode handle merge conflicts?

CrewCode surfaces exact file overlap and likely cross-file contract collisions before crew merges. It can also recover crew worktree/commit ownership and interrupted merge audit state after restart. For detailed merge review workflows, see the behavioral merge review documentation.

Is my code kept local?

Yes. CrewCode is local-first by default. The Background Brain and Hub features are optional and require explicit enrollment. When enabled, the relay is end-to-end encrypted and the Hub never sees your code, prompts, transcripts, or terminal output.

What is the plugin platform?

CrewCode's local plugin system lets developers build extensions as static HTML/JS assets loaded through sandboxed iframes. Plugins can add panels, sidebar items, editor/chat actions, git lenses, browser actions, terminal watchers, and MCP server declarations. The crewcode-plugin-api provides a typed bridge for safe postMessage communication.

Conclusion

CrewCode was built for one reason: the future of software development is multi-agent, and the tools for supervising those agents haven't caught up. With 90% of developers using AI coding agents weekly, only 22% having deployed true coding agents, and just 13% of teams running AI across the full SDLC, the gap between "agents exist" and "agents are manageable" is the defining challenge of this era.

CrewCode closes that gap with a desktop application that treats git worktrees as first-class citizens, gives every agent its own isolated environment, surfaces all activity in a single Mission Control dashboard, and keeps the developer in control through a layered security model and execution custody system.

The AI coding agent market is projected to grow from $10.4 billion in 2025 to $149.6 billion by 2034. But market size doesn't solve the coordination problem - dedicated tools like CrewCode do. Whether you're a solo developer running multiple coding agents on real repos, a technical founder using agents as parallel collaborators, or a small engineering team exploring supervised multi-agent workflows, CrewCode provides the supervision layer that makes multi-agent development actually work.

The code is open-source, the platform is provider-agnostic, and the plugin system is extensible. The future of development is multi-agent - and CrewCode is the control center for it.

Continue Learning

Fundamentals:

  • CrewCode Getting Started Guide — Install from a release or source, providers, first run
  • Using Crews — Crews: parallel lanes, supervisors, and the select → verify → reconcile → apply Merge lanes workflow
  • Git Workspace — The full-page Git tab and its relationship to the Git Sidebar

How-To Guides:

  • Keybindings — Every shortcut, defaults per group, and the editable ~/.crewcode/keys.json override file
  • Realtime Voice — Voice orb providers, coding-agent routing, natural spoken replies, credentials, and local roadmap
  • Plugins — The plugin contract: manifest, permissions, panel API, CLI workflow

Advanced:

Repo-only docs (not published on the docs site yet): Execution Custody, Security Model, and Desktop & Web Continuity are internal developer docs. See docs/execution-custody.md, docs/security-model.md, and docs/desktop-web-continuity.md in the repository.

Tools & Reviews:

CrewCode is licensed under the Apache License, Version 2.0. Copyright © 2026 OnPoint Tools.