The bottleneck of AI programming is not the model, but the fact that you can only run one agent at a time

Have you ever done the math: Claude Code takes 15 minutes to write a feature, Codex takes 10 minutes to run a test, Cursor takes 8 minutes to fix a bug. Running the three tasks sequentially takes 33 minutes. But what if all three agents worked at the same time? 8 minutes.

This is not hypothetical. The open-source project Orca, with 11.6K stars, is turning "parallel agent programming" from a concept into everyday reality. It is not just another agent, but a dispatch center that makes all agents work simultaneously — each agent runs in an independent Git worktree, interference-free, while you lie on the sofa and monitor progress from your phone.

From "queuing up for agents" to "directing agents in parallel"

Over the past year, AI programming tools have exploded: Claude Code, Codex, Cursor, Grok, Cline, OpenCode... Each can write code, but each is single-threaded. You give Claude Code a task, wait for it to finish, then give Codex the next task. The stronger the agent, the more painful the waiting.

It is like a company hiring 20 senior engineers but only giving them one desk to use in rotation.

Orca's core insight is: The bottleneck of agents is not capability, but orchestration. It positions itself as an ADE (Agent Development Environment) — not an IDE, not a terminal, not an agent framework, but an operating system specifically designed to manage "parallel agent workflows."

How exactly? With a single prompt, Orca can distribute work to 5 agents, each working in an independent Git worktree. Five code paths explore simultaneously; you compare results and merge the best solution. This is not "opening several terminal windows" — worktrees guarantee code isolation, and Orca uniformly manages diff review, commit, and merge.

Breaking it down: Orca's five-layer architecture

Layer 1: Terminal Infrastructure

Orca comes with a terminal engine based on Ghostty, WebGL rendering, and supports infinite split screens. Scrollback persists across restarts — the output from yesterday's agent is still there when you open it today. This is not decoration, but a necessity: agent output often runs hundreds of lines, and losing context means losing work progress.

The terminal also integrates the Monaco Editor (the same editor as VS Code), supporting drag-and-drop of files or images into the agent prompt. You no longer need to toggle between editor and terminal; one window handles everything.

Layer 2: Parallel Worktree Engine

This is the soul of Orca. Git worktrees allow the same repository to have multiple working directories simultaneously. Each agent modifies code, runs tests, and makes commits in its own worktree, completely isolated. Orca handles creating, switching, merging, and cleaning worktrees — you don't need to manually run git worktree add.

Even more powerful is the SSH worktree: agents can run on remote servers with full file editing, Git operations, and terminal access, with automatic reconnection on disconnect and automatic port forwarding configuration. This means your local machine is just a console, while the real computation happens in the cloud. For scenarios requiring agents to run on GPU servers or production environments, this is a necessity.

Layer 3: Agent Adapter Layer

Orca does not discriminate among agents. Claude Code, Codex, Grok, Cursor CLI, GitHub Copilot, OpenCode, Cline, Kimi, Qwen Code, Mistral Vibe, Devin, Goose, Auggie, Hermes Agent... 20+ CLI agents are all supported, and they use your own subscriptions — no duplicate payment. Orca is just a scheduling layer; it does not touch your API keys.

This "BYO subscription" model is very clever. Some agent platforms on the market require you to purchase their tokens, adding an extra layer of cost on top of a Claude subscription. Orca does not take this spread; it only does orchestration, allowing users to run more work with their existing subscriptions.

Layer 4: Review and Feedback Loop

Agent writing code is not the end. Orca's Annotate AI Diffs feature allows you to comment directly on diff lines, with comments automatically fed back to the agent. No need to switch to GitHub, no need to copy-paste diffs — the entire review → edit → commit workflow is completed within Orca.

Design Mode goes a step further: click any UI element in a Chromium window, and Orca automatically extracts HTML, CSS, and screenshots, directly inserting them into the agent's prompt. Front-end debugging transforms from "screenshot → description → agent guessing" to "click → agent precise understanding." For front-end developers, this feature is a killer experience — you no longer need to describe "the blue button in the upper right corner" in natural language; just click it.

Layer 5: Mobile Console

This is Orca's most underrated feature. Clients are available for iOS and Android, with push notifications when agents complete tasks, and you can send follow-up instructions anytime. Imagine: assign tasks to agents during your commute, and the code is ready for review when you arrive at the office. Or you find an agent going astray during lunch break, and correct its direction with a single "try another approach" from your phone.

The mobile version is not a stripped-down edition — it supports complete agent interaction, worktree management, and GitHub/Linear integration. Orca frees "programming" from the physical constraint of "sitting at a computer."

Orca CLI: Agents can drive Orca too

An easily overlooked detail: Orca is not just a tool for humans to control agents; agents themselves can control Orca.

Through CLI commands like orca worktree create, orca snapshot, orca click, orca fill, agents can script the creation of workspaces, take screenshots, click UI elements, and fill forms. This means Agent A can launch Agent B, Agent B can call Orca's Design Mode to screenshot, and Agent C can perform UI fixes based on the screenshot — multi-agent collaboration no longer requires human intervention.

Computer Use functionality takes it further: it lets agents directly operate desktop applications and visible UI. Not limited to the browser; anything you can see, the agent can see and operate.

Clear-eyed about costs: Parallel agents are not a free lunch

First the good news: Orca itself is MIT open-source and completely free. But the hidden costs of parallel agents cannot be ignored.

Token consumption scales multiplicatively. Running 5 agents in parallel on the same prompt consumes 5 times the tokens of a single agent. Claude Code's Max subscription ($200/month) has rate limits; with 5 agents running simultaneously, limits come faster. Orca's Account Switcher feature can hot-switch accounts to bypass this, but that may require multiple subscriptions.

Community members have shared extreme cases: running 5 agents simultaneously for a large-scale refactoring burned through an amount of tokens equivalent to a week's worth in single-agent mode in one day. Parallelization speeds things up by 5 times, but costs also increase by 5 times — this is not "freeloading," it's "trading money for time."

Merge conflicts are the fate of parallel programming. When 5 agents modify different parts of the same file, Git can auto-merge most of the time. But if they modify the same line, the cost of manually resolving conflicts may offset the time saved by parallelization. Orca does not have an automatic merge strategy — it provides tools, but judgment remains your responsibility.

Cognitive load does not decrease; it increases. When working sequentially, you only need to understand one agent's output at a time. When working in parallel, diffs from 5 agents appear before you simultaneously, and you need to quickly decide which solution is optimal. Not everyone can handle this — it requires a deep enough understanding of the codebase to make high-quality review decisions in a short time.

The community also has a cold voice. Someone on Reddit bluntly said: "Parallel agents sound cool, but most developers' daily tasks don't need parallelism — writing an API, fixing a bug, adding a field — sequential works in 5 minutes, and parallelism adds management overhead." This makes sense. The value of parallel agents lies in exploratory tasks (architecture selection, solution comparison, large-scale refactoring), not deterministic tasks.

Why Orca represents a trend

Orca is backed by stablyai, a Y Combinator W22 batch company with a 4-person team. Founder Jinjing Liang is a former Google Chrome senior engineer, and Neil Parker is a former Uber Tech Lead — both have experienced the pain points of large-scale engineering collaboration. With 5886 commits, 725+ releases, and 176+ contributors, this iteration speed is top-tier among open-source projects. The latest version is v1.4.120, with releases almost daily.

But more importantly, Orca represents a direction: The competition in AI programming is shifting from "whose model is stronger" to "whose orchestration is better."

2025 is called the "Year of AI Agents," but most frameworks (LangChain 100K+ stars, CrewAI 50K+ stars, AutoGen) solve the problem of "how to build agents," not "how to use agents." What developers truly need is not another agent framework, but a working environment that can simultaneously schedule multiple existing agents, manage their workspaces, and unify review output.

Orca fills this gap. It does not build agents; it builds the operating system for agents.

Microsoft unified AutoGen and Semantic Kernel into the Microsoft Agent Framework in October 2025, confirming the same trend: from fragmented agent building to unified agent orchestration. But Microsoft's solution targets enterprise-level multi-agent systems, while Orca targets individual developers' daily programming — lighter, faster, more practical.

Domestically, players are also following suit. Alibaba open-sourced AgentScope (covering the full lifecycle of agents), JD.com open-sourced JoyAgent (enterprise-level intelligent agents), ByteDance launched DeerFlow (SuperAgent architecture). But these projects still focus on "how to build agents," not "how agents collaborate." Orca's combination of worktree isolation + parallel scheduling + mobile monitoring is currently unique in the open-source community.

When to use and when not to use

Should use:

• Architecture selection, need to explore multiple solutions simultaneously — 5 agents each go their own way, 10 minutes for 5 options
• Large-scale refactoring, different modules can be processed in parallel — front-end, back-end, testing all start at once
• Exploratory tasks, uncertain of the optimal path — let agents try different approaches, you pick the best
• Remote development, need to SSH to servers to run agents — local machine only for review and decision
• Long-running tasks, don't want to stay at the computer — mobile monitoring, notified on completion

Should not use:

• Deterministic small tasks (fix a bug, add a field) — sequential 5 minutes, parallelism adds management overhead
• Limited token budget (parallelism = Tokens × number of agents) — when saving money is more important than saving time
• Developers not adept at quickly reviewing multiple diffs — 5 diffs at once, if you can't review them, it's a disaster
• Project lacks good Git habits — worktrees depend on clear branch management; chaotic Git leads to chaotic worktrees

Summary in one sentence: Orca is for those who "already know how to use agents but find agents too slow." If you are still learning how to write prompts, don't touch it yet.

GitHub: https://github.com/stablyai/orca

Website: https://onorca.dev

Installation: brew install --cask stablyai/orca/orca (macOS) | AppImage / deb (Linux) | .exe (Windows) | App Store / TestFlight (iOS)