Orca orchestrates parallel coding agents using git worktrees

The autonomous coding agent market has reached an awkward adolescence. Individual tools — Claude Code, OpenAI Codex, Google’s Gemini CLI, Grok, and a growing list of others — have grown competent enough to handle discrete tasks. But competence in isolation is no longer the point. In a widely circulated LinkedIn post, Andrew Ng identified parallel agents as a critical new direction for scaling AI performance, noting that while reasoning models and sequential agentic workflows improve results, they also make users wait. The proposed fix is to run agents concurrently, distributing cognitive labor across multiple workers much as a manager delegates to a team. The catch is that nobody has built a particularly good desk for that team to sit at. Enter Orca.

The demand is tangible. The project’s README enumerates more than two dozen supported CLI agents, from mainstream offerings like GitHub Copilot and Google’s Gemini to niche entrants like Antigravity, Pi, and Hermes Agent. Each has its own strengths, context-window quirks, and subscription model. Developers are increasingly asking not which agent to use, but how to use several at once — a question that has surfaced on public forums like Quora, where users ask explicitly for tools that can run multiple AI coding agents in parallel. Orca arrives at this exact moment, positioning itself not as another competitor in the agent race, but as the infrastructure layer that lets them coexist.

Orca is a desktop application — macOS, Windows, and Linux, with a mobile companion — that styles itself as an “AI Orchestrator.” The name is biologically apt: orcas are apex predators that hunt in coordinated pods, a decent metaphor for an application whose purpose is to coordinate groups of agents that would otherwise collide. Its central architectural bet is that git worktrees, not containers or virtual machines, are the right isolation primitive for parallel agent development. A git worktree allows a repository to maintain multiple checked-out branches simultaneously as separate directories linked to the same underlying history. Unlike cloning the repository multiple times, which forks history and complicates synchronization, worktrees share the same object database. Unlike simple branch switching, which forces a developer to stash or commit half-finished work, worktrees keep every branch materialized on disk simultaneously. Orca assigns one worktree per agent, meaning Claude Code can refactor authentication in one tree while Codex writes tests in another, both operating against the same commit graph without stepping on uncommitted changes in the developer’s main working directory. This is lighter-weight than spinning up Docker sandboxes for every agent, and more version-control-native than simply opening multiple terminal tabs and praying. The project calls the approach “worktree-native,” promising no stashing and no branch juggling. In practice, it turns a git feature that most developers use for hotfixes into an assembly line for autonomous labor.

Other tools have tried to solve multi-agent isolation through Docker containers or cloud sandboxes, which provide strong isolation at the cost of overhead and network complexity. Git worktrees, by contrast, require no daemon, no port mapping, and no volume mounts. They are simply directories. An agent that knows how to operate in a git repository already knows how to operate in a worktree. This reduces the integration surface area to nearly zero, which is likely why the project can support such a sprawling list of third-party tools without maintaining custom plugins for each.

What Orca is not matters as much as what it is. It does not ship its own foundation model, nor does it implement a bespoke coding agent. It is a neutral host for third-party CLI agents. Each runs inside Orca’s tabbed terminal interface, complete with split panes, notifications when an agent finishes, and built-in diff review so a human can inspect AI-generated changes before they migrate back to the main branch. The application adds a drag-and-drop interface for feeding files and images into agent prompts, an embedded browser for visual testing, and native markdown and PDF previews. Most autonomous agents are blind to graphical interfaces; they reason over text and file paths. Orca’s embedded browser and design mode attempt to bridge that gap, letting a human verify visual changes that an agent might have generated without ever rendering the page. It is a concession to the reality that autonomous coding still requires a human in the loop, if only to look at the result.

There is even an iOS and Android companion app, extending the control surface to mobile devices and tacitly acknowledging that autonomous coding is becoming background batch work rather than interactive pair programming. The notification system and unread-thread markers treat agents like asynchronous coworkers who might finish a task while the human is in a meeting. This is a subtle but important shift in user-interface design: the computer is no longer a passive tool waiting for input, but a team member that the user must manage. This is infrastructure, not intelligence. As Martin Fowler’s taxonomy of autonomous coding agents distinguishes, there are supervised agents embedded in IDEs and headless agents that run in cloud sandboxes; Orca sits in the middle, providing a local graphical shell for tools that are otherwise stuck in a terminal.

The project does not solve the hardest problem in parallel agentics: decomposition. Ng explicitly warns that breaking a complex task into subtasks that can be executed in parallel by agents remains difficult, just as it is with human engineers. Orca provides the isolation and the UI, but the developer still has to decide what each agent should do. It is a workbench, not a project manager. Additionally, because Orca relies on the user’s existing subscriptions and API keys — it requires no login of its own — it is essentially a sophisticated wrapper around external CLIs. If those tools change their interfaces or restrict programmatic access, Orca’s integration breaks. That is a structural dependency, not a flaw, but it means the project’s fate is partially tied to ecosystems it does not control.

This interstitial positioning is where things get interesting. Integrated environments like Cursor and Windsurf embed agents tightly into the editing surface. Headless systems like OpenAI Codex and Devin spin up cloud sandboxes and return pull requests. Orca borrows from both: it runs locally like an IDE, but treats agents as composable services that can be orchestrated across repositories and even remote machines via SSH. The C3 AI blog describes a vision of enterprise software as an adaptive network of intelligent components that reason over data and collaborate; Orca is attempting something analogous for the individual workstation, letting agents operate as distributed services within a single desktop window. It even links GitHub pull requests, issues, and Actions checks to each worktree automatically, blurring the line between local experimentation and shared delivery.

That background-batch model exposes a further tension. The C3 AI blog argues that the true transformation of autonomous coding agents lies not in developer productivity but in embedding headless agents into production systems as “living software” that adapts continuously. Orca, by contrast, is firmly a developer-facing tool. It orchestrates local and remote worktrees, but it does not deploy agents into running applications or let them self-modify production code. Its scope is the development loop, not the runtime loop. Whether that is a limitation or a sensible boundary depends on your appetite for letting loose agents mutate live systems.

Whether this becomes a permanent category or a transitional utility depends on how quickly agent providers absorb orchestration into their own products. Anthropic could make Claude Code multi-worktree aware; OpenAI could build a native Codex dashboard. But the diversity of the agent ecosystem — the fact that no single model dominates every task — suggests there is room for a neutral referee. Ng notes that falling LLM inference costs make parallel token consumption practical. Orca’s bet is that developers will want a dedicated environment to manage that consumption: a control room for a fleet of agents rather than a single chat window. The worktree is its operating table.