Conductor cierra: cómo ejecutar varios agentes de Claude Code / Codex en paralelo sin él (guía de git worktree)

En resumen:

• Según el anuncio de Conductor, Conductor se une a Meta. Desde el 4 de noviembre no hay nuevos registros ni descargas; Conductor Cloud pasa a solo lectura el 13 de noviembre y cierra el 20 de noviembre, cuando empieza a borrar los datos de los usuarios en la nube. La app local para Mac sigue recibiendo modelos nuevos y correcciones críticas hasta principios de 2027, y después se irá retirando.
• Si aún usas Conductor Cloud, haz clic derecho en cada espacio de trabajo y elige «Transfer to local» antes del 13 de noviembre, o exporta todo en Settings → Account → Export data.
• El mecanismo central de Conductor es un git worktree y una rama por espacio de trabajo, como indica su propia documentación. Puedes hacerlo sin Conductor: crea directorios con git worktree add, abre Claude Code o Codex en cada uno y al final fusiona en tu rama principal.
• En nuestra prueba del 5 de noviembre, Claude Code y Codex trabajaron a la vez en dos worktrees y cada uno escribió una función con sus pruebas. Tiempo total: 66,3 s (Claude Code 27,0 s, Codex 66,3 s), y las 11 pruebas pasaron tras la fusión. claude -w en Claude Code y --worktree en Codex también pueden crear el worktree por ti.
• Si prefieres una interfaz gráfica, mira los proyectos de código abierto Orca (MIT), Emdash (Apache-2.0) y la herramienta de terminal Claude Squad (AGPL-3.0).

Crear una API Key y ejecutar tareas de Claude Code y Codex en paralelo →

Calendario oficial

Las fechas proceden del anuncio de Conductor y del registro de cambios 0.93.0. Según TechCrunch, Meta confirmó la compra pero no dio detalles. Según Axios, Conductor fue fundada por Charlie Holtz y Jackson de Campos, y las condiciones financieras no se hicieron públicas. En X también hay un resumen de noticias en tendencia.

Lo que hace Conductor, en 4 pasos

Según la documentación de Conductor, cada espacio de trabajo nuevo recibe su propio git worktree con una rama, normalmente en ~/conductor/workspaces/<nombre del repo>/<nombre del espacio>. El agente solo edita archivos de ese directorio, las pruebas se ejecutan ahí y la rama es lo que revisas, subes y conviertes en PR.

Así que sin Conductor solo tienes que cubrir 4 pasos:

1. Una tarea, un directorio: git worktree add da a cada tarea su propio directorio y rama.
2. Un directorio, una sesión: abre una sesión de Claude Code o Codex en cada directorio.
3. Modelos configurados: conecta Claude Code y Codex a la misma API Key.
4. Fusionar y verificar: cada rama ejecuta sus pruebas y se hace commit, luego se fusiona en main y se elimina el worktree.

git worktree viene con Git: un repositorio con varios directorios de trabajo que comparten el historial pero tienen archivos separados, así que dos agentes que editan el mismo archivo no se sobrescriben en disco.

Paso 0: crear una API Key y conectar Claude Code y Codex

1. Regístrate en aicodewith.ai e inicia sesión; luego haz clic en «Gestión de claves» en la barra de navegación izquierda.
2. Haz clic en «Crear clave» arriba a la derecha y ponle un nombre fácil de reconocer, por ejemplo «agentes en paralelo - MacBook».
3. Al confirmar, copia la clave completa de inmediato y guárdala. Una vez cerrado el diálogo, la clave completa no se vuelve a mostrar; si la pierdes, bórrala y crea otra. Más detalles en la documentación para crear una API Key.

Crear una API Key →

Codex lee el archivo global ~/.codex/config.toml, así que todos los worktrees comparten ese archivo y no hay que configurar cada directorio:

# ~/.codex/config.toml
model = "gpt-6.1-sol"
model_provider = "aicodewith"

[model_providers.aicodewith]
name = "aicodewith"
base_url = "https://api.aicodewith.ai/chatgpt/v1"
wire_api = "responses"
experimental_bearer_token = "TU_API_KEY"

Claude Code lee ~/.claude/settings.json, que también es global:

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.aicodewith.ai",
    "ANTHROPIC_AUTH_TOKEN": "TU_API_KEY"
  }
}

Si aún no tienes Codex, consulta la guía de instalación de Codex. Cada campo de config.toml se explica en la guía de config.toml de Codex, y otras configuraciones de Claude Code están en Cómo conectar Claude Code a una API de terceros.

Paso 1: un worktree por tarea

Antes de empezar, añade a .gitignore los artefactos de compilación y los worktrees que crean los agentes. En nuestra primera prueba no lo hicimos y __pycache__ bloqueó la fusión (ver paso 4):

# En el checkout principal, ignora primero los artefactos de compilación y los worktrees que crean los agentes
cat >> .gitignore <<'EOF'
__pycache__/
node_modules/
.claude/worktrees/
EOF
git add .gitignore && git commit -m "ignore build output and agent worktrees"

Después crea un worktree por tarea:

cd ~/code/demo                      # tu repositorio
git switch main && git pull
git worktree add ../demo-wt/slugify  -b feat/slugify
git worktree add ../demo-wt/truncate -b feat/truncate
git worktree list

Salida:

~/code/demo              a97cf41 [main]
~/code/demo-wt/slugify   a97cf41 [feat/slugify]
~/code/demo-wt/truncate  a97cf41 [feat/truncate]

Con muchas tareas ayuda un pequeño script: le pasas un nombre, crea el directorio y una rama agent/<nombre> e imprime la ruta:

#!/usr/bin/env bash
# new-task.sh <name> [base]   crea un directorio de tarea e imprime su ruta
set -euo pipefail
name="${1:?usage: new-task.sh <name> [base]}"
base="${2:-main}"
repo="$(git rev-parse --show-toplevel)"
wt="$(dirname "$repo")/$(basename "$repo")-wt/$name"
git -C "$repo" worktree add -q "$wt" -b "agent/$name" "$base"
echo "$wt"

Uso:

cd "$(./new-task.sh fix-login)" && claude
cd "$(./new-task.sh add-export)" && codex

Ojo: un worktree solo contiene los archivos que Git sigue. Lo que no está en el repositorio, como .env o node_modules, no aparece en el directorio nuevo: cópialo o reinstala las dependencias. Eso es lo que configura la página «Configure your project» de Conductor.

Paso 2: un Claude Code o Codex por directorio

Interactivo: abre dos pestañas de terminal, entra con cd en un worktree en cada una y ejecuta claude o codex. Con tmux ves los dos en una sola pantalla:

# Claude Code a la izquierda, Codex a la derecha
tmux new-session -d -s agents -c ../demo-wt/slugify  "claude"
tmux split-window -h -t agents -c ../demo-wt/truncate "codex"
tmux attach -t agents

En nuestra prueba, Claude Code y Codex preguntaron una vez si confiar en la carpeta la primera vez que abrieron cada worktree, porque para ellos es una ruta nueva.

Desatendido: cuando la tarea está bien definida y solo quieres el resultado, ejecuta claude -p y codex exec en segundo plano a la vez:

PA="Add textkit/slug.py with slugify(s) ... Add tests/test_slug.py ... Only create these two files. Then run: python3 -m unittest discover -s tests -v"
PB="Add textkit/truncate.py with truncate(s, width, suffix='...') ... Add tests/test_truncate.py ... Only create these two files. Then run the tests."

(cd ../demo-wt/slugify  && claude -p "$PA" --allowedTools "Write,Edit,Read,Bash(python3:*)") &
(cd ../demo-wt/truncate && codex exec -s workspace-write "$PB") &
wait

Los prompts dicen «Only create these two files», lo que separa los archivos de las dos tareas y evita conflictos al fusionar. Más formas de repartir el trabajo en Cómo dividir tareas con subagentes de Codex.

Paso 3: resultados de la prueba

Entorno de prueba: 5 de noviembre de 2026, 06:16–06:30 (hora de Pekín, UTC+8), Linux, Claude Code 2.1.318, codex-cli 0.166.0 (modelo gpt-6.1-sol), nuestra propia Key; HOME y CODEX_HOME apuntaban a un directorio aislado, y el repositorio de prueba era un pequeño paquete de Python, textkit, con una sola función.

Las dos tareas arrancaron a la vez: Claude Code escribió slugify() en feat/slugify y Codex escribió truncate() en feat/truncate. Ambos debían añadir pruebas unitarias y ejecutarlas.

[Claude Code 2.1.318 · ~/code/demo-wt/slugify · feat/slugify]
All 7 tests pass. I added `textkit/slug.py` and `tests/test_slug.py`,
and those are the only files I created.
[exit 0, 27,0 s]

[Codex 0.166.0 · ~/code/demo-wt/truncate · feat/truncate]
workdir: ~/code/demo-wt/truncate
model: gpt-6.1-sol
provider: aicodewith
sandbox: workspace-write
...
Ran 5 tests in 0.000s
OK
[exit 0, 66,3 s]

Las dos tareas no se esperan entre sí, así que el total es el de la más lenta. Una detrás de otra, serían los dos tiempos sumados.

Paso 4: fusionar y verificar

Cada worktree ejecuta sus pruebas y hace commit; con todo confirmado, vuelve al checkout principal y fusiona en orden:

# En cada worktree: ejecuta las pruebas y luego haz commit
cd ../demo-wt/slugify
git status --short
python3 -m unittest discover -s tests
git add -A && git commit -m "feat: slugify"
# De vuelta en el checkout principal, fusiona
cd ~/code/demo
git merge --no-ff feat/slugify
git merge --no-ff feat/truncate
python3 -m unittest discover -s tests -v

Nuestro resultado:

*   9765c15 merge truncate
|\
| * 55ce497 feat: truncate
* |   b7b9d4c merge slugify
|\ \
| |/
|/|
| * c5c0b99 feat: slugify
|/
* a97cf41 init textkit

Ran 11 tests in 0.000s
OK

En el primer intento de fusión apareció este error:

$ git merge --no-ff feat/slugify
error: The following untracked working tree files would be overwritten by merge:
	tests/__pycache__/test_core.cpython-313.pyc
	textkit/__pycache__/__init__.cpython-313.pyc
	textkit/__pycache__/core.cpython-313.pyc
Please move or remove them before you merge.
Aborting

Las pruebas habían generado __pycache__, que se incluyó en el commit de la rama, y unos archivos sin seguimiento con el mismo nombre en el checkout principal bloquearon la fusión. Claude Code ya lo había advertido al terminar su tarea. La solución es el .gitignore del paso 1; si ya están en el commit, quítalos en la rama con git rm -r --cached antes de fusionar.

Lista de verificación:

• git status --short en cada rama muestra solo los archivos esperados;
• las pruebas de cada rama pasan, y tras la fusión se vuelve a ejecutar toda la batería en main;
• si dos ramas tocaron el mismo archivo, resuelve el conflicto como en la sección siguiente.

Al terminar, elimina los worktrees y las ramas:

git worktree remove ../demo-wt/slugify
git worktree remove ../demo-wt/truncate
git branch -d feat/slugify feat/truncate
git worktree prune
git worktree list

Sin comandos de git: claude -w y codex --worktree

Las dos CLI ya pueden crear worktrees por sí solas. En las versiones probadas, claude --help muestra -w, --worktree [name], y tanto codex --help como codex exec --help muestran --worktree («Run the session in a new managed Git worktree»). Consulta la documentación de Claude Code y la documentación de worktrees de Codex.

# Claude Code: ejecútalo desde la raíz del repositorio
claude -w words                   # = claude --worktree words
# Codex: en modo interactivo o desatendido
codex --worktree
codex exec --worktree -s workspace-write "Add title_case() to textkit/core.py ..."

Tras ejecutar las dos sesiones a la vez, git worktree list mostraba:

$ git worktree list
~/code/demo                             987a3ea [main]
~/code/demo/.claude/worktrees/words     987a3ea [worktree-words] locked
~/.codex/worktrees/f0c2/demo            987a3ea (detached HEAD)

Tres cosas a tener en cuenta:

• Ubicaciones distintas: Claude Code crea el worktree dentro del repo, en .claude/worktrees/<nombre>, en una rama worktree-<nombre>; Codex lo crea en ~/.codex/worktrees/ como detached HEAD, sin rama. Añade .claude/worktrees/ a .gitignore y crea una rama en el worktree de Codex antes de fusionar.
• Claude Code bloquea su worktree: el bloqueo sigue tras la sesión, así que un git worktree remove normal falla hasta que ejecutes git worktree unlock.
• Dos tareas sobre el mismo archivo chocan: esta vez hicimos a propósito que ambos añadieran una función a textkit/core.py.

Commit y fusión:

# el worktree de Claude Code ya está en la rama worktree-words
cd ~/code/demo/.claude/worktrees/words
git add -A && git commit -m "feat: count_words"
# el worktree de Codex es un detached HEAD, crea primero una rama
cd ~/.codex/worktrees/f0c2/demo
git switch -c feat/title-case
git add -A && git commit -m "feat: title_case"
cd ~/code/demo
git merge --no-ff worktree-words
git merge --no-ff feat/title-case

La segunda fusión dio conflicto:

Auto-merging tests/test_core.py
CONFLICT (content): Merge conflict in tests/test_core.py
Auto-merging textkit/core.py
CONFLICT (content): Merge conflict in textkit/core.py
Automatic merge failed; fix conflicts and then commit the result.

Puedes dejar que un agente lo resuelva. Ten en cuenta que claude -p necesita --permission-mode acceptEdits: en el primer intento solo pasamos --allowedTools, las escrituras de Claude Code se bloquearon y el conflicto quedó igual:

claude -p "This repo is in the middle of a git merge with conflicts in textkit/core.py and tests/test_core.py. Keep both sides, remove the conflict markers, run python3 -m unittest discover -s tests, and report the result. Do not commit." \
  --permission-mode acceptEdits \
  --allowedTools "Edit,Read,Bash(python3:*),Bash(git status:*),Bash(git diff:*)"
# haz commit solo tras comprobar que no quedan marcadores de conflicto
grep -rn '<<<<<<<' textkit tests
git add textkit/core.py tests/test_core.py && git commit -m "merge title_case"
python3 -m unittest discover -s tests -v

Salida:

A grep found no conflict markers left in `textkit/` or `tests/`.
I didn't stage or commit anything, so git still lists both files as unmerged (`UU`).
[exit 0, 17,5 s]

Ran 13 tests in 0.001s
OK

El bloqueo que encontramos al limpiar:

$ git worktree remove .claude/worktrees/words
fatal: cannot remove a locked working tree, lock reason: claude session words (pid ...)
use 'remove -f -f' to override or unlock first

$ git worktree unlock .claude/worktrees/words && git worktree remove .claude/worktrees/words
$ git worktree remove ~/.codex/worktrees/f0c2/demo
$ git branch -d worktree-words feat/title-case

¿Prefieres una interfaz? Herramientas que pueden sustituir a Conductor

Solo incluimos proyectos cuya licencia y descripción comprobamos en GitHub:

Todas usan git worktree por debajo, así que los 4 pasos de arriba siguen valiendo: la Key va en la configuración global de Claude Code y Codex, y cualquiera de estas interfaces puede usarla directamente.

Antes de paralelizar, piensa si te conviene

Más agentes no siempre es mejor. Las tareas que comparten archivos chocan, como vimos, y los pasos de una misma tarea suelen encajar mejor con subagentes:

• Ejecutar subtareas con un modelo más ligero en Claude Code: Cómo configurar un subagente Haiku 5.5 en Claude Code;
• Para flujos fijos, agrúpalos en una Skill en lugar de acumular subagentes: Convertir subagentes en una Skill de Claude Code;
• Repartir trabajo, límites de archivos y verificaciones en Codex: Cómo dividir tareas con subagentes de Codex.

Regla sencilla: funciones y correcciones independientes en worktrees paralelos; investigación, código y pruebas de una misma función en subagentes.

Crear una API Key y conectar Claude Code y Codex →

Preguntas frecuentes

¿Hasta cuándo funcionará la app local de Conductor?

Según el anuncio, Conductor local sigue funcionando con normalidad y recibe modelos nuevos y correcciones críticas hasta principios de 2027, cuando empieza a retirarse. Como las descargas están detenidas, quien no lo tenga instalado ya no puede conseguirlo.

¿Cómo exporto mis datos de Conductor Cloud?

Haz clic derecho en un espacio de trabajo y elige «Transfer to local» para llevar el espacio y sus chats a tu Mac; para exportarlo todo, Settings → Account → Export data. Se puede seguir exportando tras el paso a solo lectura del 13 de noviembre; el borrado empieza el 20 de noviembre.

¿En qué se diferencia git worktree de clonar dos veces?

Los worktrees comparten un único .git: commits, ramas y remotos son los mismos, un commit en un directorio se ve al instante en el otro y no se vuelve a descargar el repositorio. El límite: una misma rama no puede estar activa en dos worktrees a la vez.

¿Cuántos agentes conviene ejecutar a la vez?

Tantos diffs como puedas revisar. Recomendamos empezar con 2–3 y separar bien los archivos de cada tarea. Todas las sesiones pueden compartir una Key, y cada petición aparece en el registro de uso de la consola.

¿Funciona en Windows?

git worktree, Claude Code y Codex son compatibles con Windows; tmux necesita WSL. Orca y Emdash ofrecen versiones para Windows.

Fuentes

• Conductor is joining Meta (anuncio oficial)
• Registro de cambios de Conductor 0.93.0
• Documentación de Conductor: Git worktrees
• TechCrunch: Meta acquires AI coding startup Conductor
• Axios: Meta acquires AI coding startup Conductor
• Documentación de Git: git-worktree