Orca: el “herder” que convierte agentes de IA en un equipo de desarrollo

Llevo semanas corriendo varios agentes de IA al mismo tiempo — Claude Code en uno, Codex en otro, Gemini CLI, OpenCode, un par más. Y el problema nunca fue arrancarlos. El problema real llegó después: no sabía quién estaba haciendo qué, ni cómo evitar que se pisaran el código unos a otros.

Ahí entra Orca: un entorno de escritorio que se autodenomina Agent Development Environment (ADE), respaldado por Y Combinator, que corre flotas enteras de agentes en paralelo, cada uno dentro de su propio git worktree, con un navegador embebido, editor, terminal, Git Graph y hasta un Design Mode para señalar un botón y mandárselo al agente con todo el contexto visual. Y no, no es un wrapper sobre Claude. Es otra cosa.

Este artículo no es un press release. Es lo que encontré al usarlo a fondo, dónde le veo valor real, dónde me parece que exagera, y por qué creo que la conversación de fondo ya no es "¿qué IA programa mejor?" sino "¿cómo coordinamos a varias para que no se maten entre sí?".

1. Ya no estamos programando solos

Hace un par de años, el salto fue pasar del autocompletado a algo que entendía tu código. Después vino el salto de “IA que sugiere” a “agente que ejecuta”: abres una terminal, le dices “arréglame este bug”, y vuelve con un diff listo.

Ahora, en 2026, el siguiente salto está en otro lado. No es el modelo. Es la coordinación.

Porque ya no estamos eligiendo entre Claude Code o Codex o Gemini CLI o OpenCode. Estamos usando varios al mismo tiempo, y cada uno tiene su propio bucle, su propio contexto, su propia suscripción. Y la pregunta que aparece sola es:

Si ya tengo Claude Code funcionando, ¿por qué demonios necesito algo que coordine a cinco?

La respuesta corta: porque el cuello de botella ya no es el modelo, es la gestión del trabajo. Y Orca es, hasta donde he visto, la apuesta más ambiciosa que existe hoy para resolver ese problema de un solo golpe.

2. ¿Qué es un AI Herder?

Antes de hablar de Orca, vale la pena el concepto. La palabra viene de herder, pastor en inglés, y se la empezaron a poner a un nuevo tipo de herramienta: un software que no programa, sino que coordina a varios agentes que programan.

La analogía sirve:

• Un agente (Claude Code, Codex, etc.) es un perro de trabajo: ejecuta, sabe qué tiene que hacer, te trae el resultado.
• Un herder es el pastor: no muerde, no corre, no ejecuta. Pero decide cuál corre, en qué dirección, y cuándo se detiene.
• Tú eres el dueño del rebaño: pagas la suscripción, decides la estrategia, eliges al ganador.

En código, la diferencia se ve así:

Claude Code
     ↓
   código


Herder
     ↓
Claude Code
Codex
Gemini
OpenCode
     ↓
trabajo coordinado

El agente produce. El herder organiza. El humano decide.

3. Entonces… ¿qué es Orca?

Orca es un Agent Development Environment (ADE) — un acrónimo que ellos mismos acuñaron para diferenciarse del clásico IDE. La idea de fondo es simple y radical:

El problema de hoy no es “tener un agente que programa”. El problema es “tener un entorno donde varios agentes trabajan en paralelo sobre el mismo proyecto, sin destruirse entre sí, mientras tú diriges”.

Orca es, técnicamente, una app de escritorio (macOS, Windows, Linux) con un companion móvil (iOS, Android). Pero reducirlo a eso es perder la gracia. Lo que hace es:

• Levanta más de 25 agentes CLI que tú ya tienes contratados: Claude Code, Codex, Gemini CLI, OpenCode, Cursor CLI, Grok, GitHub Copilot CLI, Amp, Cline, Continue, Goose, Hermes, Kimi, Qwen Code, Mistral Vibe, y la lista sigue.[1][2]
• Le da a cada uno su propio git worktree, su propia terminal, su propio editor, su propia pestaña de navegador.[4]
• Te los muestra a todos en un panel con estado semántico en vivo: working, blocked, done, idle — sin que tengas que ir pane por pane a adivinar.[5]
• Lanza un navegador embebido por worktree, con un Design Mode que convierte un clic en la UI en HTML + CSS + screenshot directo al prompt del agente.[3]
• Tiene un Git Graph visual, navegador de código, diff viewer, y push a PR inline.

Y lo más importante — y esto es lo que cambia las reglas — no quiere ser el mejor programador de tu equipo. Quiere ser quien coordine a todos los programadores.

4. Orca no reemplaza a tus agentes

Esto es lo primero que tienes que entender para no confundirte. Orca no es Claude. Orca no es Codex. Orca no es Gemini. Orca no es un wrapper. Orca no entrena su propio modelo.

Lo que hace es correr los agentes que tú ya tienes, con tus propias suscripciones, y orquestarlos. Es el mismo modelo mental de Herdr (que ya probé en este blog) pero llevado un paso más allá: Herdr te da el runtime para terminales con agentes, Orca te da el IDE completo alrededor.

Y esa es la frase que resume todo:

Orca no quiere ser el mejor programador de tu equipo. Quiere ser quien coordine a todos los programadores.

Si ya pagas Claude Max, sigues pagando Claude Max. Si ya tienes la API key de OpenAI, sigue siendo tu API key. Orca es la capa que faltaba entre “tengo N agentes” y “tengo N agentes trabajando en equipo”.

5. La arquitectura mental de Orca

Antes de tocar el producto, conviene dibujar el modelo. Orca piensa en cinco capas:

                    TÚ
                     │
                   ORCA
                     │
        ┌────────────┼────────────┐
        ↓            ↓            ↓
     Claude        Codex       Gemini
        ↓            ↓            ↓
    tarea A      tarea B      tarea C
        └────────────┼────────────┘
                     ↓
                  Git

• Tú: defines las tareas, apruebas los merges, cierras el trabajo. Sigues siendo el director técnico.
• Orca: el herder. Asigna tareas a agentes, crea worktrees, monitoriza estados, te avisa cuando algo se queda bloqueado.
• Agentes: ejecutan. Cada uno corre en su propio proceso, con su propio contexto, con su propia suscripción.
• Tareas: el contenido real del trabajo. “Arregla este bug”, “agrega login con Google”, “escribe los tests de la clase Foo”.
• Repos + worktrees: el suelo debajo de todo. Cada tarea vive en su propia rama, en su propio directorio físico, sin pisar a las demás.

Esa última capa es la que casi nadie cuenta. Y es probablemente la decisión arquitectónica más importante que Orca tomó.

6. El arma secreta: múltiples agentes trabajando en paralelo

Aquí empieza lo divertido.

Imagina que en tu repo te llega este ticket:

“Necesito agregar autenticación, corregir un bug en el endpoint de checkout, crear pruebas unitarias del módulo de pagos y actualizar la documentación de la API.”

El enfoque clásico, con un solo agente, sería secuencial:

1. autenticación
2. bug
3. pruebas
4. documentación

Cuatro tareas. Cuatro esperas. Una mañana perdida.

Con Orca, lo que haces es:

Claude Code  →  autenticación
Codex        →  bug en checkout
OpenCode     →  pruebas del módulo de pagos
Gemini CLI   →  documentación de la API

Al mismo tiempo. Cada uno en su propio worktree, con su propia rama, sin pisarse. Tú te quedas mirando el Agent Dashboard —un kanban en vivo con columnas Needs You, Working, Done e Idle— y vas aprobando a medida que llegan.[5]

El paralelismo real no viene de tirar más procesos. Viene de que Orca le da a cada agente su propio espacio físico de trabajo. Y eso nos lleva al siguiente punto.

7. Git Worktrees: cómo evitar que las IAs se peleen

Git worktree es una funcionalidad vieja de Git (incluida por defecto desde hace años, documentada oficialmente) que te permite tener múltiples directorios de trabajo sobre el mismo repositorio, cada uno en su propia rama. Lo que Orca hizo fue convertir esa idea en la columna vertebral del producto.

En lugar del modelo clásico de “una rama, cambia, stashea, cambia otra vez, mergea, limpia”, Orca trabaja así:

/proyecto

main
 │
 ├── feature-login
 ├── fix-api
 ├── tests
 ├── documentation
 └── optimization

Cada rama es un directorio físico. Cada agente opera sobre el suyo. Si Claude está reescribiendo auth.ts en feature-login, Codex no puede ni verlo — está en otro worktree, sobre otra rama, con su propio checkout de los archivos.[4]

Y lo mejor: como cada worktree es un git worktree real, puedes hacer cd adentro y usar git a mano siempre que quieras. Orca no esconde el metal. Lo abraza.

8. El entorno de desarrollo de Orca

Hasta aquí he hablado de la parte de orquestación. Pero Orca no se queda en “multiplexor con esteroides”. Es un entorno de desarrollo completo:

• Editor de archivos integrado, con syntax highlighting y diff viewer.
• Terminales Ghostty-style, con tabs, splits verticales y horizontales, theming consistente.
• Git: control de cambios, diff contra el branch base, push a PR, Git Graph visual.
• Navegador embebido por worktree (sí, cada worktree tiene su propio navegador con sus propias pestañas — si estás en feature-login no ves las pestañas de fix-api).[6]
• Tasks: panel lateral con cards que se vinculan a issues de GitHub, Linear, GitLab o Jira.
• PRs y reviews inline: “Annotate AI Diff” te deja dejar comentarios sobre un diff generado por un agente y mandárselos de vuelta para iterar.[7]
• Mobile companion: revisas, apruebas, comentas, lanzas un agente nuevo desde el teléfono.[1]

Y la pregunta natural es:

¿Qué aporta Orca que un herder puro como Herdr no aporta?

La respuesta corta: el IDE entero. Herdr te da el runtime (la terminal con agentes, persistencia, estado semántico). Orca te da el IDE entero alrededor: editor, navegador, Git visual, tasks, PRs, mobile. Es la diferencia entre el motor y el coche.

9. Design Mode: cuando la IA puede ver lo que tú estás viendo

Esta es, para mí, la pieza más llamativa. Y la que menos he visto usar todavía.

Design Mode convierte el navegador embebido en un puntero-a-código. Tú activas el toggle, tu cursor se vuelve un picker, y cuando haces clic en cualquier elemento de la página:

• Captura el HTML del elemento y un poco del contexto.
• Captura el CSS computado (colores, fuentes, spacing).
• Captura un screenshot recortado del elemento.
• Si hay source map, captura el archivo y línea del source.

Todo eso cae como attachment al chat del agente activo. Tú escribes lo que quieres cambiar. El agente edita el source. Orca hace hot-reload. Tú haces clic otra vez para verificar.[3]

Para alguien que desarrolla front-end, esto es un antes y un después. Porque el 80% del tiempo perdido con un agente en tareas de UI no es el código en sí — es explicar qué es “ese botón”, dónde está, y qué quieres que cambie. Design Mode se salta toda esa fricción.

10. Un día de desarrollo usando Orca

Bajemos a tierra. Esta es la sección narrativa. Un día normal, no el día de la keynote.

9:00 — Abro el proyecto. Click en “Add Repo” en la sidebar. Apunto a mi checkout local. Orca lee el estado de git y detecta origin/main como base ref.[7]

9:05 — Creo las tareas del día. Cuatro worktrees desde la sidebar, nombres claros: fix-login-race, write-checkout-tests, update-api-docs, bump-deps. Cada uno con su propio branch desde main.[7]

9:10 — Asigno agentes. En el launcher de cada worktree, elijo el agente:

• fix-login-race → Claude Code (lo conozco fuerte en TS/React)
• write-checkout-tests → Codex (es bueno generando tests sin cansarse)
• update-api-docs → Gemini CLI (rápido, barato, no necesita razonamiento profundo)
• bump-deps → OpenCode (tarea mecánica, no quiero gastar suscripción buena en esto)

9:20 — Los agentes trabajan en paralelo. Abro el Agent Dashboard. Las cuatro cards aparecen en la columna Working. El spinner amarillo gira. Me preparo un café.

9:40 — Reviso los primeros resultados. OpenCode ya terminó bump-deps (era trivial). Lo reviso, hago push, abro PR. Gemini ya tiene update-api-docs listo. Lo apruebo. Claude sigue con fix-login-race (es el difícil). Codex va por la mitad de los tests.

10:00 — Comparo soluciones. Claude y Codex ya entregaron. Abro el diff viewer, comparo enfoques. Hay tres cosas que Codex hizo mejor; dos que Claude. Decido merge con lo de Claude y un cherry-pick de Codex.

10:15 — Integro. Commit, push, PR. La columna Done tiene dos entradas. Las otras dos están en Working. Sigo con la siguiente tarea.

Esa mañana, en un proyecto donde secuencialmente me hubiera tomado tres horas, hice el trabajo de cuatro en hora y cuarto. Y eso contando el café.

11. Orca + Claude Code + Codex + Gemini + OpenCode

Vale la pena hablar de esto con calma, porque es donde Orca pasa de “herramienta curiosa” a “decisión estratégica”.

No todos los agentes son iguales. No todos cuestan igual. No todos son buenos para lo mismo.

Y una idea que vale la pena dejar escrita:

No necesitas encontrar “la mejor IA”. Puedes usar varias IAs buenas para diferentes trabajos.

Esto es contraintuitivo. Toda la conversación de los últimos dos años ha girado en torno a benchmarks y rankings: cuál modelo es el más listo, cuál aprueba más tests, cuál escribe mejor código. Orca da la vuelta a esa pregunta: en lugar de buscar al mejor jugador, construyes un equipo.

12. Orca vs. un herder como Herdr

Esta comparación la voy a hacer, porque ayuda a entender dónde está cada uno.

Herdr es un runtime para terminales con agentes. Su tabla comparativa oficial lo explica mejor que yo:[8]

La diferencia de fondo: Herdr es el motor, Orca es el coche. Los dos son válidos. Herdr es perfecto si vives en la terminal y quieres persistencia real. Orca es perfecto si quieres un IDE completo y no te importa salir de la terminal a una app de escritorio.

¿Orca es Herdr con esteroides? Más o menos. Es Herdr con editor, navegador, Git visual, y un sistema de worktrees que va mucho más profundo.

13. Orca vs. Claude Code

La conclusión es directa:

No necesariamente eliges uno. Puedes usar Claude Code dentro de Orca.

Y esto es importante: no es una batalla. Orca corre Claude Code como uno más de sus 25+ agentes soportados. La pregunta no es “Orca o Claude Code”. La pregunta es “¿quieres un IDE que coordine varios, o solo un agente fuerte?”. Si ya pagas Claude y solo usas Claude, probablemente Orca te sobra. Si ya usas tres agentes y no sabes cuál terminó primero, Orca te cambia la vida.

14. Orca vs. Cursor, Windsurf y los AI IDE

Aquí hay una distinción interesante que vale la pena hacer.

AI IDE (Cursor, Windsurf) vs. Agent Development Environment (Orca). ¿Son la misma categoría?

• Cursor es un IDE con un agente adentro. Tú escribes, el agente sugiere, tú apruebas. Su página de features presume multi-agent, shadow workspaces, semantic search — pero todo es un modelo, un workspace, una sesión por flujo principal.[14]
• Windsurf (ahora Devin Desktop) es similar, con Cascade como agente y un Agent Command Center para coordinar flotas. Su post de Windsurf 2.0 anuncia justamente el Agent Command Center como respuesta a esta nueva categoría.[15]
• VS Code + agentes (Claude Code extension, Continue, Cline) sigue siendo VS Code más un plugin.

Orca se planta en otro lugar:

No soy un IDE con un agente. Soy un ADE — un entorno hecho desde cero alrededor de la idea de “varios agentes, varios worktrees, un humano que dirige”.

Es la misma diferencia conceptual que había entre “IDE con VCS integrado” (todos los IDEs modernos) y “un sistema operativo que piensa en términos de branches” (lo que Git cambió hace 20 años). Orca no quiere ser un editor con IA. Quiere ser el sistema operativo del trabajo multi-agente.

Si esta categoría se va a consolidar, Orca está apostando a ser la referencia. Cursor y Windsurf están intentando lo mismo desde sus propios ángulos. Veremos quién define la categoría.

15. Lo bueno de Orca

Sin vender humo. Esto es lo que, después de usarlo, valoro:

• Experiencia de usuario: la integración entre worktrees, terminales, navegador y editor es fluida. No se siente como “cuatro apps pegadas con cinta”. Se siente como una sola cosa.
• Multi-agente real: no es marketing. Puedes tener cinco agentes en paralelo, cada uno con su worktree, sin que se pisen.
• Paralelización segura: los worktrees eliminaron de un plumazo el “Claude pisó el código de Codex”. Eso solo ya justifica la herramienta.
• Aislamiento: cada worktree es una rama, un branch, un directorio. Si algo sale mal, borras el worktree y se fue todo.
• Git Worktrees como abstracción: la decisión de basar todo en una feature nativa de Git es brillante. No inventaron un nuevo concepto; usaron el que ya existía, que ya conoces, y que ya sabes debuggear.
• Entorno integrado: editor + terminal + navegador + Git + tasks + PRs. Todo en una ventana.
• Flexibilidad de agentes: trae el que ya pagas. No te amarra a un modelo.
• Mobile companion: poder revisar y aprobar desde el teléfono es, en la práctica, un cambio de hábito.

16. Lo que NO me gusta de Orca

Porque si todo es “wow, increíble”, el artículo pierde credibilidad. Y Orca no es perfecto.

• Complejidad: es una app de escritorio pesada. No es un binario en tu PATH. No es un script de Python. Es un software que tienes que instalar y mantener.
• Consumo de recursos: cinco agentes en paralelo, cada uno con su terminal, su navegador, su worktree. Tu laptop tiene que aguantarlo. Si tienes 8GB de RAM, lo vas a sufrir.
• Costos de múltiples agentes: si pagas tres suscripciones porque quieres tres modelos, el costo mensual se nota. Orca no te lo cobra, pero lo hace posible, y eso también es un punto en contra para algunos bolsillos.
• Curva de aprendizaje: el modelo mental de “worktree por tarea, agente por worktree, dashboard con estados” hay que entenderlo. No es obvio el primer día.
• ¿Realmente necesitas 5 agentes?: la mayoría de proyectos no lo justifican. Lanzar 5 worktrees para una landing page es disparar un cañón a una mosca.
• Riesgo de generar trabajo innecesario: el paralelismo es tentador. Terminas abriendo worktrees por abrir, sin pensar si la tarea lo amerita. Más agentes ≠ más productividad — ya lo dijo Augment en su análisis sobre cuándo el multi-agente es overkill: funciona solo cuando las tareas son paralelizables sobre módulos independientes y la coordinación no come el tiempo ahorrado.
• Supervisión humana: cinco agentes en paralelo generan cinco PRs potenciales. Alguien los tiene que revisar. Si no eres tú, no es un equipo: es un generador de basura a escala.
• Calidad vs. cantidad: tener cuatro soluciones distintas al mismo problema no significa que cuatro sean buenas. A veces significa que una era la correcta y tres eran alucinaciones caras.

17. ¿Realmente necesitamos un ejército de IAs?

Esta sección es la que más me importa, porque es donde Orca deja de ser producto y se vuelve filosofía.

Existe una trampa muy real:

Más agentes ≠ más productividad.

Un equipo de 10 programadores incompetentes no produce más que uno de 3 buenos. Con agentes ocurre exactamente lo mismo. Tener 5 agentes corriendo en paralelo no te convierte en un equipo de 5; te convierte en una persona intentando supervisar 5.

La pregunta correcta no es:

"¿Cuántos agentes puedo ejecutar?"

Es:

"¿Qué trabajo puedo paralelizar realmente?"

Y la respuesta casi nunca es “todo”. Casi siempre es: “estos dos módulos son independientes, estos dos agentes los atacan, los demás los hago yo o secuencialmente”.

Anthropic lo dice en su artículo sobre su sistema multi-agente de research: la paralelización funciona cuando los sub-problemas son verdaderamente independientes y la coordinación es barata. Cuando no, la sincronización se come la ganancia.

Cursor, en su post sobre agent swarms, midió que un swarm bien diseñado llegó al 80% de un test SQL en 4 horas, mientras que un swarm mal diseñado se atascó antes de la segunda hora. La diferencia no fue “más agentes”, fue mejor coordinación.

Orca te da la herramienta. La disciplina de saber cuándo usarla sigue siendo tuya.

18. Mi workflow ideal con Orca

Después de probarlo, así es como lo uso:

                  YO
                   │
                 ORCA
                   │
       ┌───────────┼───────────┐
       │           │           │
   Arquitectura   Código       QA
       │           │           │
    Claude       Codex      OpenCode
                   │
                   ↓
                Revisión
                   │
                   ↓
                  YO

• Yo: defino las tareas, asigno agente, apruebo o descarto.
• Orca: mantiene el estado, los worktrees, el dashboard. Me avisa cuando algo se bloquea.
• Claude Code: tareas de arquitectura, refactors grandes, decisiones de diseño.
• Codex: generación de tests, migraciones, código repetitivo.
• OpenCode: tareas mecánicas donde no quiero quemar suscripción.
• Yo: reviso, merge, pusheo. Decido qué pasa a producción.

La IA trabaja.

Yo sigo tomando las decisiones importantes.

Eso es lo que Orca no te quita. Y no te debería quitar, porque la calidad del software sigue dependiendo de las decisiones que un humano está dispuesto a defender.

19. ¿Para quién tiene sentido Orca?

Sí tiene sentido para:

• Desarrolladores profesionales que ya usan varios agentes CLI y quieren una capa de orquestación seria.
• Equipos pequeños donde cada minuto cuenta y los PRs se acumulan.
• Freelancers que mantienen varios proyectos a la vez y necesitan paralelizar.
• Proyectos grandes donde hay módulos claramente independientes (frontend / backend / docs / tests).
• Tech leads que están probando cómo escalar el uso de IA dentro de su equipo.

Probablemente NO tiene sentido para:

• Alguien que apenas empieza con IA. Si todavía no tienes un workflow con un solo agente afinado, Orca te va a abrumar.
• Proyectos pequeños. Una landing page no necesita cinco worktrees.
• Un script de 200 líneas. Ni se acerca.
• Quien solamente usa un agente ocasionalmente. Estás sobredimensionando.

20. ¿Vale la pena?

Evaluación final, sin marketing.

• ¿Qué problema resuelve? El de coordinar varios agentes en paralelo sin que se destruyan el código entre sí, y sin que tú tengas que abrir seis terminales a la vez para ver quién está haciendo qué.
• ¿Qué tan diferente es? Bastante. No hay otro producto hoy que sea un IDE completo pensado alrededor de la idea de “flotas de agentes”. Cursor y Windsurf están intentando lo mismo desde sus lados. Herdr ataca solo la capa de runtime. Orca es la apuesta más ambiciosa del grupo.
• ¿Es una herramienta imprescindible? No. Si solo usas un agente a la vez y tu proyecto cabe en una cabeza, Orca te sobra.
• ¿Es todavía experimental? Menos de lo que parece. Es un proyecto open source serio, respaldado por Y Combinator, con releases constantes y una comunidad grande. Pero está evolucionando rápido: features entran, salen, se renombran.
• ¿Qué futuro tiene? Si la categoría “ADE” se consolida, Orca tiene posibilidades reales de ser la referencia. Si no, será una herramienta más de culto entre power users.
• ¿Cambiará realmente nuestro workflow? El de mucha gente, sí. El de todos, no.

Mi nota personal, en escala de “lo abro cada día” a “lo desinstalé al segundo día”: lo abro cada día que tengo que tocar tres módulos distintos del mismo proyecto. El resto del tiempo, sigo con Claude Code solo en la terminal, como siempre.

21. Conclusión — El programador ya no es el único que escribe código

Cerramos con algo más conceptual.

Hace unos años, el flujo era este:

Programador
     ↓
Código

Después, con la llegada de Copilot y los primeros agentes, pasó a esto:

Programador
     ↓
IA
     ↓
Código

Y ahora, en 2026, con herramientas como Orca, lo que tenemos es:

             PROGRAMADOR
                  ↓
                ORCA
        ┌─────────┼─────────┐
        ↓         ↓         ↓
      AGENTE    AGENTE    AGENTE
        └─────────┼─────────┘
                  ↓
                CÓDIGO

La evolución no es que una IA sea cada vez más inteligente. La evolución es que aprendimos a coordinar muchas IAs especializadas alrededor de un humano que decide.

Y ahí es donde Orca se vuelve interesante. No por la interfaz bonita —aunque la tiene—. No por el navegador embebido —aunque mola—. No por el Design Mode —aunque eso solo ya me hizo pensar “ok, esto vale la pena”.

Se vuelve interesante porque representa el cambio de “AI coding assistant” a “AI development team”.

Bonus: ¿Y si esto apenas es el principio?

Porque si el patrón sigue, lo que hoy llamamos ADE va a ser tan normal en cinco años como lo fue en su momento “un editor con un debugger integrado”. O como lo fue en su momento “un IDE que entiende Git”.

Lo que viene no es solamente “IA que programa”.

Es:

Sistemas donde diferentes agentes diseñan, programan, prueban, revisan y corrigen software mientras el humano actúa como director técnico.

Donde el humano:

• Define el qué y el por qué.
• Delega el cómo a una flota de agentes.
• Revisa el resultado con herramientas que le dan contexto visual (Design Mode), textual (diff viewers) y operativo (dashboards de estado).
• Decide qué pasa a producción.

Y donde el sistema se vuelve auto-mejorable: agentes que observan cómo trabajas, que aprenden tus convenciones, que ajustan su comportamiento. No por arte de magia, sino porque tú les das feedback estructurado en cada review.

Orca no es esa visión completa. Es un paso muy concreto hacia ella. Pero el paso importa, porque hace visible la dirección. Y cuando una dirección se vuelve visible, el resto de la industria se mueve hacia allá.

Y esa pregunta ya no es de tecnología. Es de criterio. Y eso, curiosamente, nos devuelve a un terreno que conozco bien: el de la estrategia, el de las decisiones, el de la intención.

Pero eso es tema para otro artículo.

Fuentes

Sources:

• [1] Orca — The most powerful Agent Development Environment (ADE)
• [2] stablyai/orca en GitHub
• [3] Design Mode — Orca Docs
• [4] Worktrees — Orca Docs
• [5] Agents & sessions — Orca Docs
• [6] Per-worktree browser — Orca Docs
• [7] Your first 3-agent session — Orca Docs
• [8] Compare Herdr vs tmux, Zellij, cmux, Warp & agent managers
• [9] git-worktree Documentation (git-scm.com)
• [10] Claude Code — Overview
• [11] openai/codex en GitHub
• [12] google-gemini/gemini-cli en GitHub
• [13] OpenCode — Intro
• [14] Cursor — Cloud Agents
• [15] Windsurf 2.0: Introducing the Agent Command Center
• [16] Augment — When Multi-Agent Is Overkill
• [17] Anthropic — How we built our multi-agent research system
• [18] Cursor — Agent swarms and the new model economics
• [19] Devin AI — Windsurf is now Devin Desktop