One Scenario
You have a feature to build. The traditional approach: open Cursor, let Claude Code write it, wait for it to finish, check the result, and iterate if you're not satisfied. One agent, one path, serial waiting.
But what if you could run 5 agents simultaneously—each in its own git worktree, implementing the same feature with different strategies—and then just pick the best one to merge?
That's what Orca does. Launched in March 2026, it reached 42,000 stars by August and is YC-backed. It's not another coding agent—it's an orchestration environment for making multiple coding agents work in parallel, officially called an ADE (Agent Development Environment).
From IDE to ADE: A Leap in Granularity
Over the past twenty years, development tools evolved: editor → IDE → AI IDE.
- Editor (Vim, Emacs): manages text
- IDE (VS Code, IntelliJ): manages projects
- AI IDE (Cursor, Windsurf): manages a single AI interaction
In an ADE, the basic unit is no longer "a prompt" or "a file" but "a full working session of one agent in one worktree." You can run Codex, Claude Code, OpenCode, and Pi simultaneously, each in its own isolated worktree, without interference.
This is fundamentally different from "opening multiple VS Code windows." With multiple windows, your attention still switches serially—reading one agent's output, switching to another, switching back. Orca provides unified tracking: all agents' status, diffs, and terminal output live in one interface, side by side.
Core Mechanisms: Worktree Isolation + Mobile Monitoring
Orca's most critical design is Parallel Worktrees. Git worktrees aren't new—they allow multiple working directories of the same repo to coexist, each checked out to different branches or commits. Orca applies this mechanism to agent orchestration:
1. You give a prompt 2. Orca fans it out to N agents 3. Each agent works independently in its own worktree 4. You compare results and merge the winner
The elegance of this design: isolation is free. You don't need to copy the whole repo per agent—git worktrees share the .git directory and only create working files. Five agents on the same repo barely increase disk usage.
The second killer feature is the Mobile Companion. When your agent finishes, your phone gets a notification; if you see an agent stuck on the subway, you send a follow-up straight from your phone. This frees "watching agents" from the desktop—agents become background processes you can manage asynchronously.
Comparison with Existing Tools
| Dimension | Cursor / Windsurf | Claude Code (CLI) | Orca | |------|-------------------|-------------------|------| | Agent count | 1 | 1 | N (parallel) | | Isolation | None | None | Git worktree | | Mobile | None | None | iOS/Android | | Agent choice | Locked to vendor API | Locked to Anthropic | Any agent, your own subscriptions | | Remote | None | None | SSH worktree |
The last row is key. SSH Worktree lets you run agents on a remote beefy machine while editing and reviewing locally. This matters for tasks needing GPU or lots of memory (like running test suites or data processing).
Orca doesn't lock you into an agent vendor. You use your own Codex subscription, your own Claude subscription—Orca only handles orchestration. That's an important stance in the 2026 agent ecosystem, where vendor lock-in risk is too high.
Why Now?
The rise of ADEs is no accident. By mid-2026, the coding agent market completed its first round of consolidation: Claude Code, Codex, OpenCode, and Cursor Agent each established their footing. Single agents are already strong—Claude Code can independently complete medium-sized PRs; Codex excels at system-level refactoring.
But single agents have a hard ceiling: they're serial. One agent finishes a task before you can start the next. If you have 5 independent bugs to fix, or 3 implementation approaches to compare, serial waiting is wasted time.
That's where parallel orchestration delivers value. Not making agents smarter, but letting multiple sufficiently-smart agents work at once—like the jump from single-core to multi-core CPUs. Once single-core performance hits a physical wall, multi-core is the only way out.
Orca's growth confirms this: 42,000 stars, a GitHub Trending regular within 4 months of launch. What it captures isn't a specific feature need but a productivity paradigm shift for the agent era.
Remaining Questions
Orca isn't a silver bullet. Several concerns:
1. Merge conflicts: 5 agents each modify their own worktree—what happens when merging? The docs say "compare the results and merge the winner," but in practice, if two agents modified different parts of the same file, merging still requires human intervention.
2. Attention allocation: Can you really review 5 diffs at once? Mobile notifications solve "knowing it finished" but not "understanding what it did."
3. Cost: Each agent consumes your API quota. 5 agents running 10 minutes in parallel equals 50 minutes of API usage. For token-billed users, that's not trivial.
4. Vendor dependency: While Orca doesn't lock agents in, it depends on the stability of the agent ecosystem. If Anthropic changes Claude Code's interface, Orca must follow.
The Bigger Picture
Orca represents a trend bigger than itself: development tools are shifting from "assisting humans to write code" to "orchestrating agents to write code."
The endgame isn't Orca itself but a question: when agents become capable enough to independently handle most coding tasks, what is the human's role?
Orca's answer: humans become commanders—not writing code, but deciding which agents do what, comparing results, and merging winners. The mobile companion reinforces this metaphor: you don't need to sit at a computer; agents notify you when they're done.
This model differs sharply from the traditional image of software engineering. The traditional engineer is a "craftsman at the keyboard"; the ADE-era engineer is more like a "project manager"—managing multiple agents' workflows rather than doing the work personally.
That's not a bad thing. It means the leverage on engineering productivity has grown—what one person can accomplish shifts from "how many lines you write" to "how many agents you can orchestrate." It also means orchestration skill is becoming a new core competency.
Orca is the first tool to productize that orchestration capability. It won't be the last.
---
Project: https://github.com/stablyai/orca Website: https://onorca.dev License: MIT Platforms: macOS / Windows / Linux / iOS / Android