Orca: el ADE para orquestar una flota de agentes de código en paralelo

¿Qué haces cuando Claude Code propone una solución, Codex otra distinta y Gemini una tercera? Lo normal es elegir un agente de antemano y quedarte con lo que produzca. Orca cambia esa dinámica: los corre a los tres a la vez, cada uno aislado en su propio git worktree, y te deja comparar los resultados y fusionar el que ganó. Es un ADE (Agent Development Environment) de código abierto —MIT, de Stably AI—: un entorno pensado para que trabajen los agentes de código en paralelo, no una persona escribiendo línea por línea. Lo probé para orquestar una flota de agentes y esto es lo que hace hoy, con la versión que shippearon esta misma semana.

En este artículo:

• Fundamentos — Qué es Orca y qué significa un ADE · Por qué paralelizar con worktrees aislados
• Implementación — Qué agentes y plataformas soporta hoy · Cómo instalar Orca · El CLI: automatizar worktrees y terminales · Fan-out de un prompt a varios agentes
• Operación — La capa de orquestación · Design Mode, navegador y diffs · Móvil y worktrees por SSH · Limitaciones y cuándo conviene

Qué es Orca y qué significa un ADE

Un IDE está diseñado para que una persona lea, escriba y depure código. Un ADE cambia el usuario principal: quien opera el entorno es el agente, y la persona pasa a coordinar, revisar y decidir. Orca se describe como “el ADE para trabajar con una flota de agentes en paralelo”, y esa frase resume bien lo que lo distingue de un editor con un chat lateral pegado encima.

La diferencia práctica es que Orca no asume un agente, sino varios corriendo a la vez. En lugar de abrir una terminal, lanzar un agente y esperar, montas varios agentes en paralelo, cada uno con su terminal, su navegador y su contexto, y los ves a todos en un mismo lugar. Es de código abierto (licencia MIT), escrito casi todo en TypeScript, y corre con tu propia suscripción de cada agente: no hay una capa de facturación intermedia, usas tu cuenta de Claude, de Codex o la que sea.

Conviene aclarar un malentendido antes de seguir: Orca no compite con Claude Code o Codex, los ejecuta. La comparación útil no es Orca contra un agente, sino Orca contra las otras formas de trabajar con agentes. El eje que importa es uno: ¿la herramienta está pensada para un agente o para varios en paralelo?

Dicho de otro modo: los tres primeros están diseñados alrededor de un agente resolviendo una tarea, y correr varios en paralelo es algo que montas a mano si acaso. Orca invierte el punto de partida: la unidad no es el agente, es la flota. Y como los envuelve en vez de reemplazarlos, dentro de Orca sigues usando Claude Code o el agente que prefieras. (El panorama se mueve rápido y varias de estas herramientas añaden funciones de agentes en paralelo; la tabla es la foto de hoy, no una sentencia.)

Por qué paralelizar con worktrees aislados

El detalle técnico que hace que todo esto funcione es el git worktree. Un worktree es una copia de trabajo adicional del mismo repositorio, con su propia rama y sus propios archivos, compartiendo el historial de git. Orca crea uno por tarea. Así, dos agentes que tocan los mismos archivos no se pisan: cada uno escribe en su worktree, sobre su rama, sin stashes ni conflictos de checkout.

Eso abre el patrón central de Orca: mandar el mismo prompt a varios agentes a la vez y comparar. Cada agente resuelve la tarea a su manera, en su worktree, y al final revisas los resultados uno al lado del otro y fusionas el que quedó mejor.

                 prompt
                   │
     ┌─────────┬───┴───┬─────────┐
     ▼         ▼       ▼         ▼
  Claude     Codex   Gemini     Grok
  worktree   worktree worktree  worktree
     │         │       │         │
     └─────────┴───┬───┴─────────┘
                   ▼
          comparas y fusionas
           el mejor resultado

Sin aislamiento esto sería inviable: cuatro agentes editando la misma copia de trabajo terminan en un desastre de archivos a medio cambiar. Con un worktree por agente, cada intento es independiente y descartable. El que no sirve se borra sin tocar el resto.

Qué agentes y plataformas soporta hoy

Si el agente corre en una terminal, corre en Orca. Hoy vienen preconfigurados más de 25 agentes de CLI —Claude Code, Codex, Gemini, Grok, Cursor CLI, GitHub Copilot, OpenCode, Pi, Cline, Continue, Droid— y cualquier otro se añade a mano. Como cada uno corre con tu suscripción, Orca incluye cambio de cuenta y seguimiento de uso para Claude y Codex. En plataformas cubre las tres de escritorio y móvil:

El proyecto shippea a diario: al escribir esto, la última versión es la v1.4.124 (6 de julio de 2026), con varios release candidates por día. Cualquier lista de features envejece rápido, así que revisa la página de releases antes de dar algo por sentado.

Cómo instalar Orca en cada plataforma

En escritorio es un comando o un instalador —Homebrew en macOS, un helper de AUR en Linux:

# macOS (Homebrew)
brew install --cask stablyai/orca/orca

# Linux (AUR, con yay)
yay -S stably-orca-bin

# Windows: instalador .exe desde la página de releases
# Móvil: iOS en App Store / TestFlight, Android vía APK

El CLI no se instala aparte: viene con la app. Se habilita una vez en Settings → Experimental → CLI y, a partir de ahí, el binario orca queda disponible en tu terminal (orca status --json confirma que quedó bien).

El CLI: automatizar worktrees y terminales

El CLI es lo que vuelve scriptable a Orca: desde la terminal gestionas worktrees, controlas las terminales de los agentes, abres archivos y diffs, y automatizas el navegador integrado. Casi todos los comandos aceptan --json para encadenarlos y parsear la salida. Los dos grupos que más usé son worktree y terminal:

# Cada tarea vive en su propio worktree: lista los que están corriendo
orca worktree ps --json

# Crea uno nuevo atado a un issue y arranca un agente en su terminal
orca worktree create --repo id:<repoId> --name fix-login --issue 123 --json
orca terminal create --worktree active --command "claude" --json

# Manda texto al agente y espera a que quede inactivo antes del siguiente paso
orca terminal send --worktree active --text "corre los tests" --enter --json
orca terminal wait --for tui-idle --timeout-ms 30000 --json

El comando que hace la diferencia es orca terminal wait --for tui-idle: bloquea hasta que el agente termina de trabajar en su terminal. Sin él, un script que despacha trabajo a un agente no tiene forma de saber cuándo continuar; con él, puedes secuenciar pasos —crear worktree, lanzar agente, mandar prompt, esperar a que termine, leer el diff— sin adivinar tiempos.

Fan-out de un prompt a varios agentes

Con esos comandos, el patrón de “un prompt, varios agentes” es un script corto. La idea: por cada agente de la lista, crear un worktree aislado, lanzar el agente en su terminal y mandarle el mismo prompt. Al terminar, tienes N intentos independientes de la misma tarea, listos para comparar.

// fan-out.ts — reparte un prompt entre varios agentes, cada uno en su worktree
import { execFileSync } from "node:child_process";

const AGENTS = ["claude", "codex", "gemini"];

function orca(args: string[]): { id: string } {
  // El CLI de Orca devuelve JSON con --json; lo parseamos para encadenar pasos.
  const out = execFileSync("orca", [...args, "--json"], { encoding: "utf8" });
  return JSON.parse(out);
}

function fanOut(repoId: string, prompt: string): void {
  for (const agent of AGENTS) {
    // Un worktree aislado por agente: sin conflictos de rama ni de archivos.
    const wt = orca(["worktree", "create", "--repo", `id:${repoId}`, "--name", `try-${agent}`]);
    // Lanzamos el agente en su terminal y le mandamos el mismo prompt.
    orca(["terminal", "create", "--worktree", `id:${wt.id}`, "--command", agent]);
    orca(["terminal", "send", "--worktree", `id:${wt.id}`, "--text", prompt, "--enter"]);
  }
}

fanOut(process.argv[2], process.argv[3]);

# fan_out.py — reparte un prompt entre varios agentes, cada uno en su worktree
import json
import subprocess
import sys

AGENTS = ["claude", "codex", "gemini"]

def orca(args: list[str]) -> dict:
    # El CLI de Orca devuelve JSON con --json; lo parseamos para encadenar pasos.
    out = subprocess.check_output(["orca", *args, "--json"], text=True)
    return json.loads(out)

def fan_out(repo_id: str, prompt: str) -> None:
    for agent in AGENTS:
        # Un worktree aislado por agente: sin conflictos de rama ni de archivos.
        wt = orca(["worktree", "create", "--repo", f"id:{repo_id}", "--name", f"try-{agent}"])
        # Lanzamos el agente en su terminal y le mandamos el mismo prompt.
        orca(["terminal", "create", "--worktree", f"id:{wt['id']}", "--command", agent])
        orca(["terminal", "send", "--worktree", f"id:{wt['id']}", "--text", prompt, "--enter"])

fan_out(sys.argv[1], sys.argv[2])

<?php
// fan_out.php — reparte un prompt entre varios agentes, cada uno en su worktree

const AGENTS = ["claude", "codex", "gemini"];

function orca(array $args): array {
    // El CLI de Orca devuelve JSON con --json; lo parseamos para encadenar pasos.
    $parts = array_map("escapeshellarg", [...$args, "--json"]);
    $out = shell_exec("orca " . implode(" ", $parts));
    return json_decode($out, true);
}

function fan_out(string $repoId, string $prompt): void {
    foreach (AGENTS as $agent) {
        // Un worktree aislado por agente: sin conflictos de rama ni de archivos.
        $wt = orca(["worktree", "create", "--repo", "id:$repoId", "--name", "try-$agent"]);
        // Lanzamos el agente en su terminal y le mandamos el mismo prompt.
        orca(["terminal", "create", "--worktree", "id:{$wt['id']}", "--command", $agent]);
        orca(["terminal", "send", "--worktree", "id:{$wt['id']}", "--text", $prompt, "--enter"]);
    }
}

fan_out($argv[1], $argv[2]);

Esto es la versión manual del fan-out. Sirve para entender el mecanismo, pero para coordinar de verdad una flota —con dependencias entre tareas, reintentos y decisiones bloqueantes— Orca trae una capa dedicada por encima del CLI.

En una prueba mandé el mismo refactor a cuatro agentes a la vez. Un par tocaron archivos que no debían, uno se quedó a medias y otro lo resolvió limpio. A cambio de correr varios en paralelo, no tuve que iterar sobre una única solución a medias. Lo que hizo útil el ejercicio no fue que uno acertara, sino poder verlos a la vez y descartar los worktrees fallidos sin que ninguno hubiera tocado mi rama principal.

La capa de orquestación: coordinar la flota

Lanzar cinco agentes es fácil; coordinarlos es el problema real. La capa de orquestación de Orca existe para eso: un agente coordinador reparte trabajo a agentes trabajadores y sigue su avance mediante un sistema de mensajes y tareas compartido. Se instala como un skill que el coordinador usa:

# Instala el skill de orquestación para que el agente coordinador lo use
npx skills add https://github.com/stablyai/orca --skill orchestration

# Despacha trabajo a los agentes libres y deja que Orca gestione el bucle
orca orchestration run --max-concurrent 4 --json

Por debajo hay cuatro piezas que conviene conocer:

• Mensajes: notas persistentes entre terminales, con tipos como dispatch (asignar trabajo), worker_done (terminé), escalation (me atasqué) o decision_gate (necesito una decisión).
• Tareas: unidades de trabajo con su especificación, sus dependencias y un estado (pending, ready, dispatched, completed, failed, blocked). Se pueden encadenar en un DAG cuando una depende de otra.
• Despachos: la asignación de una tarea a una terminal concreta. Si falla, se puede reintentar con contexto fresco.
• Decision gates: preguntas que pertenecen al coordinador y bloquean una tarea hasta que se resuelven. Es el punto donde una persona decide antes de que la flota siga.

El reparto no es a ciegas: despachas a grupos con direcciones como @all (todas las terminales), @idle (las que están libres), @codex (por tipo de agente) o @worktree:<id> (una concreta). Cada trabajador recibe un preámbulo con las reglas de comunicación y, al terminar, reporta con un worker_done que incluye los IDs de la tarea y del despacho. Con orca orchestration run, Orca gestiona ese bucle por ti hasta un máximo de trabajadores concurrentes.

Design Mode, navegador y revisión de diffs

Buena parte del trabajo de un agente no se juzga leyendo el diff, sino viendo el resultado en pantalla. Orca le da a cada worktree su propia ventana de Chromium. En Design Mode puedes hacer clic sobre un elemento de la interfaz y mandarle al agente el HTML, el CSS y una captura de ese elemento, para que corrija justo eso sin describirlo con palabras.

La revisión también está pensada para el ida y vuelta con el agente. El visor de diffs deja poner comentarios en markdown sobre líneas concretas y enviárselos de vuelta para que refine el cambio. Y como las integraciones de GitHub y Linear están dentro de la app, puedes revisar PRs e issues sin cambiar de ventana. Las terminales, por su parte, son de la clase de Ghostty: renderizado por WebGL, splits infinitos y un scrollback que sobrevive a los reinicios.

Móvil y worktrees por SSH

Dos features amplían dónde corre la flota. La primera son los worktrees por SSH: puedes correr los agentes en una máquina remota potente —con edición de archivos completa, git y terminales— y Orca se encarga de la reconexión automática y el reenvío de puertos. Útil cuando tu laptop no da para varios agentes a la vez y prefieres un servidor.

La segunda es el móvil. Las apps de iOS y Android no son un visor de solo lectura: dejan monitorear a los agentes, recibir una notificación cuando uno termina y mandarle un mensaje de seguimiento desde el teléfono. Combinado con la ejecución remota, puedes lanzar una flota, salir, y darle indicaciones desde el celular mientras trabaja.

Limitaciones y cuándo conviene usar Orca

Orca no es magia, y correr una flota tiene su costo. Antes de adoptarlo conviene tener presente:

• El costo se multiplica con los agentes. Correr la misma tarea en varios agentes multiplica el consumo de tokens en proporción a cuántos lances. El fan-out paga cuando la tarea es difícil y vale comparar enfoques, no para cambios triviales.
• Comparar y fusionar sigue siendo trabajo humano. Orca facilita ver los resultados lado a lado, pero decidir cuál sirve y hacer el merge lo haces tú. Con muchos worktrees a la vez, esa revisión se vuelve el cuello de botella.
• El CLI es experimental. Hay que habilitarlo a mano y su superficie cambia entre versiones. Un script que hoy funciona puede necesitar ajustes tras una actualización, sobre todo shippeando a diario.
• Cada agente se comporta distinto. El mismo prompt rinde diferente en Claude Code, en Codex o en Gemini. La flota compara enfoques, pero no elimina la necesidad de conocer las manías de cada agente.

Resumido para decidir rápido:

Usa Orca cuando:

• la tarea admite varias soluciones y vale la pena compararlas;
• quieres enfrentar varios agentes o LLM sobre el mismo problema;
• el costo extra de tokens compensa encontrar una mejor implementación;
• vas a revisar y fusionar los resultados.

No lo uses cuando:

• es un cambio pequeño y lineal;
• un solo agente resuelve la tarea sin dudas;
• no vas a revisar lo que produce la flota: sin revisión, el paralelismo no aporta nada.

Si trabajas con un solo agente para cambios lineales, un IDE normal con su extensión te alcanza; el ADE empieza a pagar cuando el trabajo es genuinamente paralelo.

Si vienes de operar un solo agente, ayuda tener claros los fundamentos antes de saltar a la flota: qué es un agent loop y cómo se comporta un agente dentro de un repo real. Orca es la capa que pone varios de esos loops a correr a la vez.

Preguntas frecuentes

¿Orca es gratis?

Sí. Es de código abierto con licencia MIT y las apps de escritorio y móvil no tienen costo. Lo que pagas es la suscripción de cada agente que uses (Claude, Codex, etc.), porque Orca corre con tu propia cuenta y no cobra por encima. No hay una capa de facturación intermedia.

¿Necesito saber usar git worktrees para usar Orca?

No para el uso normal. Orca crea y gestiona los worktrees por ti; los ves como “tareas”, cada una con su terminal y su rama. Entender el concepto ayuda a razonar por qué los agentes no se pisan, pero no tienes que ejecutar comandos de worktree a mano salvo que quieras scriptear tu propio flujo con el CLI.

¿Puedo usar un agente que no venga en la lista?

Sí. Orca envuelve cualquier agente que corra en una terminal. Los más de 25 preconfigurados (Claude Code, Codex, Gemini, Grok, Cursor CLI, OpenCode y otros) son atajos, pero si tu agente se lanza con un comando de shell, lo puedes añadir como comando propio.

¿En qué se diferencia el CLI de la capa de orquestación?

El CLI (orca worktree, orca terminal, orca file) opera Orca desde la terminal: crear worktrees, mandar texto a un agente, leer diffs. La capa de orquestación va por encima: da tareas con dependencias, despachos, reintentos y decision gates para que un agente coordinador reparta trabajo entre varios trabajadores y siga su avance. Uno es el mando manual; la otra, la coordinación estructurada de la flota.

¿Corre en móvil de verdad o solo monitorea?

Las apps de iOS y Android dejan monitorear y también dirigir: recibes una notificación cuando un agente termina y puedes mandarle un mensaje de seguimiento. La ejecución del agente ocurre en tu máquina de escritorio o en un box remoto por SSH; el teléfono es el control remoto, no donde corre el trabajo pesado.

Conclusión

Orca parte de una idea que suena obvia una vez que la ves: si vas a trabajar con agentes de código, el entorno debería estar hecho para varios a la vez, no para uno. El worktree aislado por tarea es lo que lo hace posible sin que se pisen, el CLI lo vuelve scriptable, y la capa de orquestación convierte “lanzar cinco agentes” en “coordinar una flota” con tareas, despachos y decisiones bloqueantes. Empieza por instalarlo y correr dos agentes en paralelo sobre una tarea real; cuando veas los dos worktrees lado a lado y descartes el que no sirve sin tocar tu rama, el resto del modelo mental encaja solo. Y como shippean a diario, revisa la página de releases: lo que leíste aquí es la foto de hoy.

Fuentes

• Orca — sitio oficial (onorca.dev)
• stablyai/orca — repositorio en GitHub
• Documentación del CLI de Orca
• Capa de orquestación de Orca
• Releases de Orca en GitHub
• Skill orca-cli