Elegir agente de código ya no es elegir modelo

Durante dos años, elegir con qué programar con IA era elegir modelo. Ese razonamiento dejó de funcionar en 2026. Los cuatro agentes que usa casi todo el mundo —Claude Code, Codex, Copilot y Cursor— corren los mismos modelos frontera, con ventanas de contexto del mismo orden y precios que en el tope de gama son idénticos: el millón de tokens de entrada sale 10 dólares tanto en GPT-6 Astra como en Claude Fable 5.1, y 50 la salida.

Hay una prueba más contundente que cualquier tabla de precios: desde febrero de 2026, en GitHub podés asignarle la misma issue a Claude, a Codex y a Copilot al mismo tiempo, y comparar los tres pull requests que abren. Si el modelo fuera el factor decisivo, esa función no tendría sentido.

Lo que quedó como diferencia real es el arnés: el programa que rodea al modelo y decide qué lee, qué puede ejecutar, dónde corre y cuánto te pregunta antes de hacer algo. Eso es lo que estás eligiendo ahora, y es una decisión sobre cómo querés trabajar, no sobre qué modelo es más inteligente.

Un ejemplo de lo que significa en la práctica. Le pedís lo mismo a dos agentes —“arreglá el bug que hace fallar este test”— con el mismo modelo detrás. Uno te muestra qué archivos va a leer, te pide permiso antes de tocarlos, corre el test delante tuyo y para si algo no cierra: terminás en diez minutos habiendo visto cada paso. El otro se lleva la tarea a una máquina en la nube, prueba tres enfoques en paralelo y a los veinte minutos te deja un pull request en borrador: no viste nada, y ahora tenés que revisar. El modelo escribió código parecido en los dos casos. Lo que cambió —cuánto te enteraste, cuándo, y qué podías interrumpir— lo decidió el arnés.

Lo que se igualó

Conviene tener claro qué dejó de ser un argumento de venta, porque es la mitad de la decisión que podés descartar:

• Los modelos. Los cuatro te dejan elegir entre modelos de Anthropic, OpenAI y Google, y cuando sale uno nuevo aparece en todos con semanas de diferencia.
• El contexto. El millón de tokens dejó de ser noticia; lo tienen los modelos que corren todos.
• MCP. El protocolo para conectarles herramientas externas lo adoptaron todos. Un servidor MCP que escribís hoy sirve en los cuatro.
• AGENTS.md. El archivo de instrucciones del proyecto dejó de ser propietario. Lo mismo que escribís para uno lo lee el otro.

Claude Code: para supervisar y personalizar

Claude Code vive en la terminal y está pensado para que lo dirijas de cerca y lo moldees a tu proyecto. Es el que más superficie de personalización expone, en cuatro capas que conviene no confundir: las skills (conocimiento que carga solo cuando hace falta), los hooks (comandos de shell que se disparan en momentos del ciclo de vida, y que por ser código no dependen de que el agente se acuerde), los subagentes (instancias nuevas con su propio contexto, que devuelven solo un resumen) y los agent teams, donde un orquestador reparte trabajo entre varios que se mensajean entre sí.

Esa misma flexibilidad es su costo: hay que configurarlo para que rinda, y correr varios agentes en paralelo consume tu cuota en paralelo. Diez agentes gastan diez veces más rápido, algo que no es evidente hasta que llega la factura.

Codex: para delegar

Codex hace la apuesta opuesta. En vez de darte control fino sobre un agente que mirás trabajar, te da límites más gruesos y la expectativa de que le delegues la tarea entera: corre en sandboxes aisladas en la nube, lanza varios agentes en paralelo y vuelve cuando terminó. Desde el 4 de septiembre de 2026 su modelo por defecto es GPT-6 Astra, pensado justamente para tareas largas de muchos pasos.

La contracara es la que tiene siempre delegar: si arrancó con el criterio equivocado, te enterás al final. Sirve mucho mejor para trabajo acotado y verificable —una migración mecánica, un bug con test que falla— que para algo donde la definición del problema se va aclarando mientras se resuelve.

Copilot: el que probablemente ya tenés

Copilot es el que menos se elige y el que más se usa, porque en muchas empresas viene dado. Su agente trabaja de forma asincrónica desde GitHub mismo: levanta una máquina virtual en Actions, hace los cambios y abre un pull request en borrador. No está en tu editor mirándote programar; está en el flujo de revisión, que es donde tu equipo ya trabaja.

Si es lo que tenés, lo que más rinde es usarlo donde es más fuerte —tareas que terminan en un PR revisable— y no pelearlo para que sea un compañero interactivo, que es justamente lo que no es. Dicho de otra forma: las tareas que le mandarías a alguien por ticket le salen bien; las que resolverías sentado al lado de alguien, no.

Vale la pena aclararlo porque es el caso más común y el peor atendido: tener Copilot impuesto no te impide usar otro para lo que Copilot no hace. Los cuatro conviven en el mismo repositorio sin configurarse nada especial, justamente porque leen el mismo AGENTS.md.

Cursor: el IDE es el producto

Cursor es el único de los cuatro donde el agente no es un agregado sino la razón de ser del editor. Su apuesta de 2026 es el control de autonomía: un selector para subir o bajar cuánta libertad le das según la tarea, en vez de tener un solo modo. Sus agentes de fondo corren sobre worktrees de git o máquinas remotas, que es la forma prolija de tener varios trabajando sin que se pisen.

El precio de entrada es cambiar de editor. Si ya vivís en VS Code o en un JetBrains, eso pesa más que cualquier diferencia de funciones.

Cómo elegir según el trabajo

La pregunta útil no es cuál es mejor, sino cuánto vas a mirar:

• Trabajo que entendés bien y querés dirigir paso a paso —arquitectura, refactors grandes, algo donde el criterio importa más que la velocidad—: un agente que supervisás de cerca, con la personalización puesta en tu proyecto. Claude Code está construido para eso.
• Trabajo acotado, repetitivo y verificable —migrar cincuenta archivos, arreglar un bug con un test que falla—: delegación en paralelo. Codex está construido para eso.
• Equipos donde todo pasa por el pull request: el agente que ya vive ahí te ahorra integrar nada. Copilot está construido para eso.
• Si el editor es donde pasás el día y querés el agente ahí: Cursor, con el costo de mudarte.

Y una regla que vale para los cuatro: el agente no compensa un repositorio que no se puede verificar solo. Sin un comando que corra los tests, ninguno de los cuatro puede saber si lo que escribió funciona — de eso hablamos en detalle acá.

La foto de hoy, que va a envejecer

Esta sección es la que conviene leer con fecha. Según la encuesta AI Pulse de JetBrains (abre en una pestaña nueva), tomada entre mayo y julio de 2026 sobre desarrolladores profesionales:

Agente	Adopción	Venía de (enero 2026)
Claude Code	39 %	18 %
GitHub Copilot	21 %	29 %
Codex	16 %	3 %
Cursor	12 %	18 %

Claude Code es hoy el más usado y el que más creció en términos absolutos; Codex es el que más creció en proporción, multiplicando por cinco en medio año; Copilot sigue segundo pero bajando; Cursor bajó en uso aunque lo conoce tres de cada cuatro.

Dos advertencias sobre estos números. La primera es que salen de una sola encuesta: son una señal, no un censo. La segunda es que vas a encontrar titulares diciendo que Codex superó los cinco millones de usuarios semanales —un dato de OpenAI, no de la encuesta— que no miden lo mismo: ahí adentro hay gente que no programa, y de hecho es el segmento que más rápido crece. Compararlo contra el 39 % de Claude Code es comparar cosas distintas.

Lo que sí conviene decidir una vez

El corolario práctico de que el modelo se haya vuelto intercambiable es que lo que construís alrededor del agente vale más que el agente. Un AGENTS.md bien escrito, tests rápidos y un repositorio que se verifica solo funcionan igual en los cuatro, y siguen funcionando cuando cambies.

Esa es la inversión que no se pierde. La elección del agente, en cambio, es reversible y probablemente la revises en seis meses — porque los números de arriba van a ser otros, pero la pregunta de cuánto querés mirar va a seguir siendo la misma.