Openly Sharing the Burn Recipe | Orca: From Beginner to Master — The Secret to One Person Commanding a Swarm of AI Agents

I once posted a screenshot of my token consumption and said I felt ashamed — I’d burned through a ridiculous amount of tokens without producing anything of real value, and the paying users on my SaaS site were only just starting to trickle in. Ironically, what people seemed more interested in was how I could sustain that level of consumption for so long. So here I am, openly sharing my multi-agent command recipe: Orca.

Once again, to Mother Earth: I’m sorry for burning so many tokens with nothing to show for it.

Orca is a free, open-source AI development workbench that lets you command multiple coding agents — Claude Code, Codex, whatever — in a single window. Each agent gets its own independent copy of the code, so they never step on each other’s toes.

This article walks through, in order: what Orca is, how it’s better than your current workflow, what a day with it looks like, how to get your first task running in ten minutes, and then specific use cases one by one. Finally, I’ll cover its flaws and when you should not use it.

If you’ve never heard of Orca, start from the top. If you already have it installed, skip to Section 6 and jump straight to “Racing Three Agents.”

Orca ships with a full command-line interface, but you rarely need to type commands yourself. If something is clickable in the UI, I’ll tell you where to click. If it’s not, the agents inside Orca will call the CLI for you — you just need to know what to ask them to do.

---

1. Meet Orca in 30 Seconds

If you remember only one thing: Orca is a development workbench built for agents.

An IDE is for humans writing code. Orca officially calls itself an ADE — Agent Development Environment — built for humans and a team of agents to work together.

A few key facts:

• It’s made by Stably, open-source on GitHub under the MIT license, with Y Combinator backing per their website. The repo was created on March 17, 2026, and at the time of this writing it already has 88,773 stars. Available on macOS, Windows, and Linux, with iOS and Android mobile apps.

• It doesn’t come with its own models. It runs whatever you already have installed and logged into — Claude Code, Codex, Cursor, OpenCode — the website lists 27 options, with the last one being “any other CLI agent.” You keep paying for your existing subscriptions; Orca itself is free. The official docs also state that it doesn’t sell hosted servers — when you run tasks remotely, you’re using machines and cloud accounts you control.

So installing Orca means no switching models, no switching accounts. You keep paying the same way you always have.

---

2. Anyone Can Open Multiple Windows — Orca Manages What Comes After

You might think: “I can just open a few terminal windows and run multiple agents myself.”

You can. The hard part is everything that comes after opening those windows. You’ll hit four problems in quick succession:

First: the copies won’t run. To keep agents from interfering with each other, each needs its own independent copy of the code. But a fresh copy pulled from Git is clean code — the .env file with your secrets isn’t in there, and neither are the installed dependencies. The moment the agent starts up, it’s stuck on missing dependencies and missing keys.

Second: you can’t keep watch. Five windows open — which one is working, which one is stuck waiting for your confirmation, which one finished long ago? You have to tab through them one by one.

Third: you can’t review fast enough. Code generation keeps getting faster, and the bottleneck is now your review. Five sets of changes in front of you — each one needs to be read, critiqued, and your feedback accurately relayed back.

Fourth: you’re locked into one vendor. If you only use one company’s agent, you stop when the quota runs out. If you want another model to pick up where it left off, the context doesn’t carry over.

Orca’s standout advantage is that it has a dedicated design for each of these four problems. Fresh copies automatically inherit specified config files and shared dependencies. When an agent finishes, Orca sends a notification and plays a sound. Changes can be annotated line by line and sent back in one batch, with AI-written lines clearly marked. Agents are vendor-agnostic — you can switch accounts and hand a session off to another company’s agent.

There’s another design that rarely gets mentioned: Orca is built not just for humans, but for agents themselves. Agents can open new workspaces on their own, read errors from other windows, and operate the built-in browser. The orchestration I’ll discuss later works because the “project manager” dispatching work is itself an agent, relying on exactly these capabilities to assign tasks and collect results.

On the flip side: if you only use one vendor’s agent and do one thing at a time, Orca won’t help much. The official client is enough. Its value is proportional to how many agents you run in parallel and how many changes you need to review.

---

3. A Day with Orca: One Person

Here’s a hypothetical day. You’re solo-building an AI SaaS for overseas users: a website plus a database, with Stripe for subscriptions. Each step below references the section where you can learn more.

9 AM — The morning checkup report is already generated. A scheduled task on your cloud server checked the repo for new changes; only if there were changes did it wake up the model. It summarized yesterday’s blockers. On days when the repo hasn’t moved, it skips entirely — zero quota spent. (Section 14)

10 AM — You discover that the same payment sometimes opens two subscriptions for the user. You spin up three workspaces and have Claude Code, Codex, and Cursor all fix it simultaneously. Whichever finishes first, Orca pops a notification. (Sections 6, 7)

Noon — The main session has been going for dozens of rounds and is starting to slow down, forgetting earlier constraints. You right-click to hand it off to a new session, passing only the latest progress, and switch to Codex to continue. (Section 8)

2 PM — Three cards on the pricing page are uneven in height. In the built-in browser, you click on the offending card with your mouse. The agent receives its code, styles, and a screenshot, and fixes it in one pass. (Section 9)

4 PM — Before launch, you make one agent the project manager and have two others review the frontend and backend separately. You only look at the final summary. (Sections 11, 12)

6 PM — You pin comments directly onto specific code lines in the changeset and send it all back for rework in one batch. The database migration step has a gate that requires your approval. (Section 10)

Evening — You close your laptop; tasks keep running on the cloud server. On the commute, the agent has a question and you reply from your phone. (Section 13)

Throughout this day, you never tab through windows to find who’s waiting on you, and you never have to describe “that button in the upper right corner” to an agent.

---

4. Get Your First Task Running in 10 Minutes

The official docs distill the entire product into one line: add repo → open workspace → pick agent → split view → review changes → commit.

Install. On macOS, one Homebrew command does it. On Windows and Linux, grab the installer from the website.

First launch. Orca requests access to your home directory and asks whether to import your existing Claude Code, Codex, and Ghostty terminal settings. Import them and your current config carries over.

Add a repo. Click Add Repo on the left sidebar and pick a local project folder. Orca reads its default branch; every new workspace branches from here.

Open a workspace. Click the + next to the repo name and give the task a name like “Fix payment callback.” If you leave the name blank, Orca names it after a sea creature. It prepares an independent code copy in the background.

Pick an agent. A new window opens in the workspace with a dropdown — choose Claude Code, Codex, or another agent. Orca launches it inside that copy using your own login.

Split view. Drag a tab to the right edge or bottom of the pane to split.

Review and commit. When the agent finishes, open the changes view for that workspace to see what it changed. If you’re happy, commit, push, and open a PR directly from Orca.

Once it’s running, take a moment to learn the layout. Left sidebar: entry points and project list, with workspaces nested under each project and running agents listed under each workspace — showing model names and run durations. Center: tabbed — agent sessions, terminals, the built-in browser, and the file editor are all tabs you can split at will. Right: file browsing, search, and changes. Bottom status bar: shows how much quota each account has used and when it resets — glance at it before launching a new session to avoid running out of quota mid-task.

---

5. Let New Agents Hit the Ground Running

You open a new workspace and the agent immediately reports missing environment variables and dependencies. This is the first dealbreaker in parallel development.

The reason, as explained earlier: the new copy is clean code — anything not tracked by Git isn’t included. Orca’s solution is a manifest you set up once at the project root: which files to copy into every copy (like the .env with secrets), and which directories to share across all copies (like hundreds of MB of node_modules, so they don’t get reinstalled each time). Write the manifest once, and every new workspace follows it automatically. The Repository page in Settings also has a Worktree Shared Paths option — a few clicks to configure.

With this set up, a new agent can get the project running the moment it starts.

The second thing to configure is project rules. Orca doesn’t have a dedicated “shared memory” panel — what works are rule files the agents read themselves: Claude Code reads CLAUDE.md, Codex reads AGENTS.md. Put them at the project root, and every new, derived, or dispatched agent will read them as long as they work in this project. Since Claude now supports AGENTS.md, I only maintain a single AGENTS.md.

In my case, a sufficient set of rules looks like this:

• Use this tech stack; do not introduce new UI libraries.
• Existing tests can only be added to — never modified or deleted.
• For database migrations, payment keys, or production environments, stop and ask me first.
• When you’re done, run the checks and clearly state what was verified and what wasn’t.

Commit the rules file to Git. New copies only see what’s in Git — if your rules file isn’t committed, agents in new workspaces can’t see it.

And don’t write dozens of rules at once. When an agent repeatedly makes the same mistake, add a rule then.

---

6. For Bugs Where Getting It Wrong Is Expensive: Race Three Agents

The same payment occasionally opens two subscriptions for a user — most likely Stripe’s webhook is sending duplicates and the code isn’t guarding against it. Getting this kind of bug wrong means real money in refunds.

The official docs offer a ready-made playbook, and it’s Orca’s most representative use case: have three agents fix it simultaneously.

Open three workspaces from the same starting point, launch Claude Code, Codex, and Devin in each, paste the same request, and split into a three-column view to watch them work. When all three finish, review each changeset, pick the best one, refine it with line-by-line annotations, and commit + open a PR in its workspace. Delete the other two workspaces in one click — the copies and branches are cleaned up together.

I really agree with the official rationale for this approach: different agents make different mistakes. If all three change the same line, it’s probably right. If each one changes a different spot, that’s the genuinely hard part of the problem. In effect, you spend one round of waiting time and get three answers plus a “map of where the disagreement is.”

This trick requires cost accounting. An Orca review on the blog andrew.ooo puts it bluntly: three Claude Code agents in parallel means three times the Anthropic quota. What you save is your retry time — but the quota bill is still triple. So only race agents on things where getting it wrong is painful — payments, permissions, data migrations. For a copy change, don’t bother.

I think this is a major reason my token consumption is so high!

If the three results are each half-right, Orca won’t merge them automatically. You can have the winning agent do another round referencing the other changes, or manually cherry-pick the good parts from the others.

---

7. Three Agents Running in Parallel — You Don’t Have to Watch

Three agents running at once — you can’t exactly stare at three windows for half an hour.

Orca runs agents, not just terminals, so it can tell the difference between an agent genuinely finishing and merely pausing. When an agent goes from working to idle, Orca sends a system notification, plays a sound, and marks the corresponding workspace. A bell icon at the top aggregates all unread notifications — one click jumps to that workspace and pane. The macOS Dock icon also shows the unread count. Notifications can be toggled by category, and you can replace the notification sound with your own audio file.

The official docs say it plainly: set up three agents, walk away, come back when the first one is done.

For logs, use split view. On macOS, Cmd+D splits right, Cmd+Shift+D splits down. Agent writes code on the left; run the site on the right to see errors.

Right-click a window to copy the pane’s ID. Send the log pane’s ID to the agent, and it can go read the errors there itself — no more copy-pasting line by line.

The right-click menu also has Quick Commands — perfect for saving the test commands you run ten times a day. One click to execute.

---

8. When the Session Gets Dumber and Quota Is Running Low

After dozens of rounds, the context grows longer, the agent gets slower, and it starts forgetting constraints agreed to earlier. The right-click menu has two features built for exactly this situation.

Derive Agent Session

You’re halfway through one approach and want to try another without disrupting the main line. For example, you’ve half-built the payment flow with Stripe and want to see how much work it’d take to switch to Lemon Squeezy.

Right-click and choose Derive Agent Session. Orca opens a new workspace, launches a new agent, and hands it a draft summarizing the current conversation — you can edit the draft before sending. The new session is a peer to the original, like branching off the main branch. If plan B fails, just delete it — the main line is untouched.

It’s also a full new session, so that draft counts against its context, and every subsequent turn is billed as usual.

Continue in New Session (renamed “Hand Off to Another Agent” in the latest version)

I recall someone previously built a custom skill for this exact purpose — now it’s built in and no longer needed.

Right-click and select this option; Orca starts a new session from the current progress, and the original session remains unchanged.

There are two ways to carry context. Focused handoff (recommended): the new session gets only the latest progress and current workspace, and reads older details on demand. Full session transcript: the new agent reads the entire history first. The UI warns about this — it’s slower and consumes a lot of context and quota.

The dialog also lists the agents installed on your machine, so you can have Codex pick up where Claude left off, and vice versa. In version 1.4.224, it was renamed “Hand Off to Another Agent,” and the official team now treats it as the entry point for cross-agent handoff. When one account’s quota is about to run dry, this is the smoothest way to keep going.

If Orca can’t confirm the new session received the context, it’ll remind you to check the new session’s input box. If it’s empty, click Copy Prompt and paste it yourself.

Recover a Session from Last Week

Orca can search agents’ session history, and even across machines. Which agent fixed which bug last week? Search a keyword and it comes right up.

---

9. Front-End Styling Without “Describing Where”

“Move that card in the upper-right corner down a bit” — tiring for you to say, and the agent often edits the wrong thing.

Each Orca workspace has a real Chromium browser. Open your site, enable Design Mode from the toolbar, and click the element with your mouse. Orca hands the current agent the element’s code, the browser-computed actual styles, and a cropped screenshot — all at once. If your dev environment is configured correctly, it also includes the source file and line number. The andrew.ooo review calls this a sleeper feature — the most underrated one.

Three pricing cards — Free, Pro, Team — have different heights. Click the shortest one, then add:

Align the bottom buttons on all three pricing cards. Preserve the existing click behavior. Check both desktop and mobile widths.

The page refreshes automatically after the edit. Click the same spot again to verify. Note: source file detection depends on your dev environment — clicking a random live website won’t find corresponding code in your local project.

Agents can use this browser too. You can have one agent build a feature and another open the browser to walk through the flow for you: “fill out the form, submit, check the success or error page, try again.” Put the test account credentials, which buttons are allowed, and what counts as success into the task description.

---

10. Review Without Squinting: Annotations, AI Attribution, and Gates

Agents write code faster than you can read it. You need tools to help with review.

Line-by-Line Annotations

Spot a problem on a line while reviewing changes? Click the + next to the line number, or park your cursor on the line and press c. Pin your comment to that line. After finishing a pass, click Send to Agent — Orca compiles all annotations into a single message and delivers it to the agent you choose. Resolved comments get marked as such; unresolved ones carry over to the next batch.

Annotations work best when structured as “under what circumstances, what’s wrong, what’s expected”:

After a request timeout, the button is re-enabled here, but the previous request may have already succeeded. Check whether an existing subscription exists before allowing a resubmit.

Which Lines Were Written by AI

Orca tracks every line an agent writes into a file and shows a small marker in the changes view. Lines you manually edit in AI-written code revert to “human-written.” When reviewing code, flagged lines deserve a second look. This marker lives only in Orca locally and is never committed to Git — export it if you need a record.

If the project is hosted on GitHub, the PR page also shows a Fix broken checks button — when automated checks fail, one click hands the failure reason to an agent to fix.

Gate for High-Risk Actions

The most feared scenario: the agent eagerly runs the database migration itself. Orca’s orchestration supports a gate called a Gate: attach a question to a specific task, like “Execute the reviewed subscription table migration?” with options “Approve and Execute” or “Continue Investigating.” If no selection is made, the task stalls right there.

One critical detail you must know: the project manager agent itself also has the authority to approve gates. Unless you explicitly write “this gate can only be decided by me” into the task, it may well approve it itself and then explain the migration as “already agreed to.” The gate’s value is recording the decision on the task — who, when, and what they chose, auditable after the fact. Who holds approval authority is something you must specify explicitly.

---

11. Making an Agent the Project Manager: Orchestration

In my opinion, this is currently the part of Orca that helps me the most — it’s absolutely fantastic!

Orchestration is easy to mistake for “opening several agents.” It’s actually about making one agent the project manager: breaking down tasks, assigning them to other agents, collecting updates, and verifying results. You only talk to that one manager.

The most important design to understand here: “work orders” and “this particular run” are tracked separately.

Example: the agent investigating the checkout API drops its connection halfway through. What needs to be investigated hasn’t changed — only this run failed. Orca’s approach: the work order stays the same, and a new run is opened under the same order, noted as “continuing from the previous failed run.” All prior records are preserved, and late-arriving messages from the old run don’t get mixed with the new one. If the same work order fails three times consecutively, Orca stops retrying and alerts you that it’s time to investigate the root cause.

This reveals Orca’s design philosophy: it only asserts what can be proven. When an agent is dispatched, Orca distinguishes between “the task instructions were delivered” and “the model actually started working.” Some agents don’t report whether they’ve started; Orca honestly records “unable to confirm.” If you assume an agent is working just because you saw “dispatch successful,” you’ve misread the information Orca gave you.

Three terms to keep straight: handoff, supervision, and scheduling. “Hand off to another agent to continue” is a full handoff — the original agent is done with it. “Assign to two agents, with you supervising through acceptance” is orchestration. “Every weekday morning” is the scheduled tasks we’ll cover in a later section. Be precise about which one you mean when briefing agents, so they know what to wait for.

---

12. Orchestration in Practice: Two Agents Reviewing the Checkout Flow in Parallel

The payment bug is fixed. Before launch, have two agents review separately — one for the backend, one for the frontend. You only look at the final summary.

On first use, Orca prompts you to Enable orchestration. Click it, and it installs the tools agents need to coordinate with each other.

Then pick one agent as the project manager and hand it this prompt (feel free to copy it directly):

Please run a supervised parallel review using Orca orchestration. You are the coordinator responsible for answering questions from the other two agents, verifying evidence, and wrapping up once both tasks have clear results.

Target: the subscription checkout flow in this project.

A: Read-only review of payment webhook handling, subscription state persistence, and failure retries. Write results to api-review.md.

B: Read-only review of the pricing page, checkout redirect, and payment failure page messaging. Write results to ui-review.md.

Neither agent changes code, commits, touches production data, or sends external messages. Each finding should specify the file, how to reproduce it, evidence, and severity. If no issues are found, state what scope was checked.

Once both reports are in, verify key findings against the code yourself and write a summary: confirmed issues, ruled-out issues, missing evidence, and recommended fix priority.

The dispatched agents can’t see your conversation with the project manager, so the task description must be self-contained like the above: goal, what can be touched, what’s off-limits, what to deliver, and what counts as done.

The project manager handles everything else. Roughly:

It opens an inbox for this collaboration, then dispatches both agents simultaneously. Since both are read-only, they share the current code — no separate copies needed.

Then it waits. When the agents have questions, alerts, or finish, messages go into this inbox. When it wakes up, it gets a whole batch — maybe Agent A’s completion report and Agent B’s question arrive at the same time. It answers B’s question, and A’s report is still in the same batch waiting to be reviewed.

Only after processing the entire batch does it tell Orca “I’ve reviewed this batch.” Unacknowledged messages keep reappearing — this is intentional, to prevent things from slipping through. For agents that have finished, it archives their output and closes the window, which remains searchable afterward.

This round counts as successful if three conditions are met: both reports actually exist, the content matches the code, and the project manager personally verified key findings. Both agents might say there are no issues, and both might have missed the same thing.

If you need a third agent to re-review after the first two finish, tell the project manager: “C should start only after both A and B complete.” Orca records this ordering — A and B must finish before C can begin — but whether C actually starts is still the project manager’s call. If B doesn’t depend on A’s results, don’t force a sequence; that just wastes a round of waiting.

When making code changes, there’s a trap: if A modifies the API in its copy and B modifies the page in another, both finishing doesn’t mean the changes auto-merge. Decide before review which copy is authoritative and who handles the merge.

Once tasks are running and you want to narrow scope, just relay a message through the project manager to the relevant agent, e.g., “For this round, only check credit card payments.” The agent reads messages during natural pauses — when starting a new file or between test runs — rather than being interrupted mid-thought. If the change is significant, wait for an explicit reply before proceeding.

---

13. Close the Laptop, Tasks Keep Running

Close your laptop lid and local agents stop. Orca has several ways to move work to always-on machines, differing in who owns the workspace environment:

• Local: agents, terminals, and browser all run on the same machine as the UI. For everyday development.
• SSH Remote: agents run on a remote machine; code and changes stay on your laptop. For people who already have a dev box, GPU host, or cloud server. Since 1.4.224, Orca automatically installs its required runtime on remote machines, no longer failing due to version mismatches.
• Remote Orca Server: an always-on machine runs Orca — projects, workspaces, terminals, and agents all live there. Your laptop and phone just connect in to view and operate. Close the laptop; tasks keep running.
• Cloud VM: one disposable cloud VM per workspace — currently in experimental features.

These approaches can be mixed within the same Orca instance.

The tweeter Asa (@app_sail) published a long post on October 9, 2026, using Remote Orca Server: installed Orca as a server on the US cloud computer that comes with Grok Bot — which, per his article, has 16 GB of RAM — and connected his MacBook and phone’s Orca clients via Tailscale to directly control Claude Code running on the cloud machine.

Asa@app_sail · Oct 9 — Article: “Hand this article to Grok Bot: I’ll set you up with Claude on Orca + Tailscale for a 24/7 always-online Claude Code cloud host” In short: register Claude on Grok Bot, install Orca on the built-in US cloud computer (16 GB RAM) and treat it as a remote server; your MacBook and phone’s Orca connect via Tailscale to directly control Claude Code running on Grok Bot… 119 31 51.8K 456K

Follow this approach in four steps:

Step 1: Network connectivity. Install Tailscale on the cloud server, laptop, and phone, all logged into the same account. Tailscale creates a private network tunnel between your devices — nothing needs to be exposed to the public internet. The official docs recommend Tailscale or your own private network.

Step 2: Install and log into agents on the server. Logging in Claude Code on your laptop doesn’t log it in on the server — install and authenticate separately. Whether a Claude account can be registered in your region is governed by Anthropic’s terms; I won’t go into that here.

Step 3: Start the Orca server on the server and tell it to advertise using the Tailscale address. If it’s the desktop version, go to Settings → Remote Orca Servers → select Advertise this app as a server, then click New Link to generate an access link. For a headless Linux server, launch in Orca’s service mode — it prints pairing information, and if you need to connect your phone, ask it to generate a phone pairing code. Also set Orca to auto-start on boot and auto-restart on crash — you can hand this off to the Claude Code on the server to configure.

Step 4: Client access. On the laptop, select Add Server on the same settings page and paste the link. On the phone, install the Orca mobile app and scan the QR code to pair.

Once connected, two settings to check: which machine new projects default to — see Active Server in settings. And if you want the built-in browser to run on the server, set the browser to Server (streamed) in browser settings — otherwise, when your laptop sleeps, browser automation breaks.

The pairing link is the key to the entire environment on that server — anyone who has it can command your agents. Only share it with your own devices. The server side can revoke access for any specific device.

In the 1.4.223 release notes, the Orca team themselves noted: the current Remote Server is still experimental and may have bugs; Orca Server 2.0 is coming soon. For important tasks, test with small ones for a few days first.

The mobile app is officially marked beta. It can view workspaces and agent status, read terminal output, answer agent questions, and view changes and make commits. It always operates sessions on your computer or server — if the host is down, the phone shows nothing. Commits and window closes from the phone really do execute. Complex merges and long report reviews are still best done on the big screen.

---

14. Automated Morning Checkup Every Day — No Work, No Cost

Scheduled tasks have a hidden waste: every day at the scheduled time, a large model wakes up — even if nothing in the project has changed.

Orca’s left sidebar has Automation for scheduled tasks — hourly, daily, weekday, or weekly. It has a cost-saving design called a probe: when the time comes, it first runs a very lightweight check, like “Are there any new changes in the project?” Only if changes exist does it wake the model. Otherwise, it logs “skipped” — zero quota spent.

You can simply tell the agent in Orca:

Create a scheduled task for me: on weekdays at 9 AM Beijing time, first check if there are uncommitted changes in the project; if none, skip. If there are, do a read-only review, summarize blockers and things that need my decision. Don’t modify files, don’t commit, don’t send external messages. Create it as disabled first — I’ll manually run it once to verify, then enable it.

There are several deliberate choices in this prompt:

Be explicit about the timezone. If the server is in the US, its system time probably isn’t Beijing time — your “9 AM” could become midnight.

Specify it runs in your current workspace so it can see your uncommitted changes. Otherwise, each run opens a fresh clean copy with nothing in it.

Disable first, manually run once, verify results, then enable — so a typo in the task definition doesn’t waste quota every single day.

Version 1.4.224 added another cost-saving option: each scheduled task can specify its own model. For a morning checkup, a cheap small model is plenty. I think Haiku 5.5 is more than capable for this!

Scheduled tasks execute on whichever machine they’re stored on. Stored on your laptop? The laptop sleeping means they won’t run on time. For true 24/7, store them on the cloud server.

If you need to send the morning checkup report to a partner who doesn’t have Orca, the agent can use Orca’s Artifacts to turn the report into a web link viewable without logging in. The first attempt will be denied — this is intentional. External publishing is disabled by default and can only be enabled by you in the desktop Settings → Artifacts page. Agents can’t sneak your files onto the public internet. Review before sharing; make sure no internal paths, keys, or customer data are included. Revoke access anytime.

---

15. Its Flaws, and Who It’s Not For

It’s an Electron app. The andrew.ooo reviewer measured it: the installer is roughly 250 MB, and idle memory usage with a few agents running is 400–800 MB — not counting the agents themselves or the built-in browser.

Parallel means more quota. Three agents racing means three times the consumption.

Updates are extremely fast. The official team ships daily. From version 1.4.200 on September 11, 2026, to 1.4.224 on October 10, stable releases kept rolling out. The upside is bugs get fixed fast — like 1.4.222 fixing an issue where pressing Enter with the Chinese IME to select a candidate would accidentally trigger send. The downside is features and menu names change — “Continue in New Session” being renamed is one example. For teams, pin a version and check the release notes for known issues before upgrading.

Several headline features still carry experimental or beta tags: Remote Server, the mobile app, Cloud VM, and the new chat-style interface.

Independent copies solve agents stepping on each other’s files — but merge conflicts and your review workload? It doesn’t reduce either.

Who it’s not for:

• People who use only one vendor’s agent and do one thing at a time
• People short on system memory
• Teams that need strictly pinned tool versions and can’t keep up with frequent updates

---

16. How to Choose: Find the Shortest Path

Every decision follows one principle: the shortest reliable path. If you can finish it directly, don’t build a workflow. If a local change suffices, don’t start over. If one session can solve it, don’t spin up orchestration.

When the requirements aren’t clear yet, don’t orchestrate. Orchestration manages division of labor and tracking — it can’t figure out “what actually needs to be done.” Dispatch three agents and you’ll get three different misunderstandings.

When a task has been split but each piece requires careful review from you, don’t split. The time saved by parallelism gets repaid in full at review time.

I also haven’t seen any reliable data proving “running five agents multiplies efficiency by X.” Speed depends on whether the task can be cleanly decomposed and how expensive your review is.

---

17. A Practical Path from 0 to 1

Level 1: One person, one session. Install Orca, import your existing agent settings, and get through “add repo → open workspace → pick agent → review changes → commit.” Configure the files to copy into each copy, shared dependencies, and rules files. Learn split view and line-by-line annotations. You pass when you can independently assess what the agent changed and whether it overstepped its bounds.

Level 2: One person, several threads. Race three agents on expensive-to-fail problems. Use derived sessions to test uncertain approaches. Hand off long conversations to new sessions. Switch to Design Mode for front-end issues. For your first foray into orchestration, start with a read-only parallel review and understand what the project manager does at each step.

Level 3: One person, an always-on team. When you genuinely have independent development tasks, let orchestration handle code changes — each agent gets its own copy, and you decide up front who merges. Set gates for high-risk actions. Turn repeated checks into scheduled tasks with probes. When you truly need to close the lid and keep running, set up Remote Orca Server and the mobile app — and remember it’s still experimental.

Orca updates fast. After upgrading, you can have the agent in Orca read the new version’s release notes first, then follow along with this article.

If you’ve made it this far, I think you have a solid understanding of Orca. Borrowing a line from a Jinjiu (劲酒) ad: Orca is great, but don’t get too greedy!