# Cómo conectar Codex, Claude Agent y OpenCode a Devin Desktop mediante ACP en 2026 > Cómo conectar Codex, Claude Agent y OpenCode al editor Devin Desktop mediante el protocolo ACP. Comandos de instalación, ajustes y planes. Source: https://ailoot.ai/blog/es/codex-claude-agent-opencode-devin-desktop-acp/ Canonical: https://ailoot.ai/blog/es/codex-claude-agent-opencode-devin-desktop-acp/ Language: es Publisher: Ailoot (https://ailoot.ai/) Translation: guide-076 Revision: sha256-d3242486513b18cfcaaf871903258e5f77a0901f88ce64ba9fe592abd5eeb558 ## ¿Qué es ACP en 2 minutos?
Puntos clave ACP es un estándar abierto para la comunicación entre un editor y un agente de IA. Con licencia Apache 2.0 y basado en JSON-RPC, ACP permite conectar agentes de OpenAI, Anthropic, Google y equipos independientes a un mismo editor, donde se comunican contigo a través de la misma interfaz.
En agosto de 2025, Zed Industries publicó Agent Client Protocol como una especificación abierta. A finales de 2025, JetBrains se había sumado oficialmente a su desarrollo y en diciembre anunció la compatibilidad con el protocolo en IDE 25.3 RC. La idea es sencilla: hay decenas de editores con IA y decenas de agentes, y antes cada combinación de editor y agente requería su propia capa de integración. ACP estandariza esa capa.

Agent Client Protocol es un estándar abierto que permite que cualquier agente se integre fácilmente con cualquier editor.

— Zed, https://zed.dev/acp
Una analogía habitual es que ACP para los agentes de IA es como LSP para los servidores de lenguaje. Cuando Microsoft publicó LSP, dejó de ser necesario escribir una integración independiente para VS Code en el caso de Python, otra para Rust y otra para Go. Cada lenguaje ejecutaba un servidor LSP conforme al estándar, y cualquier editor compatible con LSP podía integrarse con él. En junio de 2026, la especificación está estable en la versión 1. Se han publicado SDK oficiales para TypeScript, Python, Rust, Java y Kotlin. Doce productos han anunciado compatibilidad con ACP en editores: Zed (de forma nativa y como creador del protocolo), los IDE de JetBrains a partir de 2025.3, VS Code, Neovim, Emacs, marimo y otros cinco productos de nicho. Devin Desktop, el editor de Cognition, destaca entre ellos: se lanzó el 2 de junio de 2026 e hizo de ACP una parte central de su interfaz desde el principio. Encontrarás información sobre cómo trabajar con Ailoot en la [documentación](https://ailoot.ai/docs/). ## ¿Qué debes instalar antes de empezar?
Puntos clave Necesitas Devin Desktop versión 3.0.21 o posterior (publicada el 4 de junio de 2026), acceso a un plan Pro, Max o Teams y las herramientas CLI de los tres agentes instaladas: Codex, Claude y OpenCode. Sin las CLI, el editor simplemente no puede indicarles que se inicien.
El acceso a ACP en Devin Desktop depende del plan de suscripción. En el plan gratuito, Free, el acceso a agentes de terceros mediante ACP está desactivado. La documentación lo indica expresamente:

Los agentes ACP están disponibles para usuarios de Pro, Max y Teams.

— Documentación de Devin, https://docs.devin.ai/desktop/acp
Pro cuesta 20 $ al mes. Es suficiente para un desarrollador individual que quiera probar una configuración con tres agentes. Max, a 200 $ al mes, solo hace falta si ejecutas Devin Cloud continuamente en segundo plano. Teams, a 80 $ por equipo más 40 $ por miembro, está pensado para grupos que necesitan Spaces compartidos. La principal limitación de ACP en Devin Desktop actualmente es que el editor **no descarga agentes del registro por su cuenta**.

Devin Desktop todavía no descarga las distribuciones de agentes directamente del registro.

— Documentación de Devin, https://docs.devin.ai/desktop/acp
Esto significa que tienes que instalar manualmente las tres CLI —Codex, Claude y OpenCode— de antemano. El editor no las detectará como agentes conectables hasta que hayas instalado los binarios. La forma más rápida de instalarlas en macOS y Linux: ```bash # Codex CLI de OpenAI npm install -g @openai/codex # Claude Code de Anthropic (el adaptador ACP lo proporciona el adaptador comunitario claude-agent-acp que aparece abajo) npm install -g @anthropic-ai/claude-code # OpenCode (código abierto) curl -fsSL https://opencode.ai/install | bash ``` Después de cada comando, comprueba que el binario esté disponible en PATH: ```bash codex --version claude --version opencode --version ``` Si un comando no responde, es posible que npm haya instalado el binario fuera de PATH o que curl haya fallado debido a un tiempo de espera de red. No tiene sentido continuar; primero corrige la instalación. ## ¿Dónde se configuran los agentes ACP de Devin Desktop?
Puntos clave Todos los agentes ACP de Devin Desktop se declaran en `~/.windsurf/acp/registry.json`. Es un archivo JSON normal que contiene una lista de objetos: id, name, version, description y la ruta al binario de cada plataforma. Cualquier agente personalizado usa el mismo formato, y el editor lo detectará automáticamente la próxima vez que se inicie.
Cognition conservó la conocida ruta de Windsurf en lugar de cambiar `.windsurf` por `.devin`. Es práctico: tus configuraciones anteriores siguen funcionando como antes.

La configuración del registro local de agentes está en ~/.windsurf/acp/registry.json para Devin Desktop y en ~/.windsurf-next/acp/registry.json para Devin Desktop Next.

— Documentación de Devin, https://docs.devin.ai/desktop/acp
Una entrada de un agente en el registro tiene este aspecto: ```json { "id": "codex-cli", "name": "Codex", "version": "0.42.0", "description": "OpenAI's coding agent", "authors": ["OpenAI"], "license": "Apache-2.0", "distribution": { "binary": { "darwin-arm64": { "path": "/opt/homebrew/bin/codex", "args": ["--acp"] }, "darwin-x64": { "path": "/usr/local/bin/codex", "args": ["--acp"] }, "linux-x64": { "path": "/usr/local/bin/codex", "args": ["--acp"] }, "win32-x64": { "path": "C:\\Program Files\\codex\\codex.exe", "args": ["--acp"] } } } } ``` El campo clave es `path`. Indica dónde se encuentra en tu disco el archivo ejecutable de la CLI. Si la instalaste mediante npm, la ruta suele ser `~/.nvm/.../node/.../bin/codex` o `/usr/local/bin/codex`. Puedes encontrarla con `which codex`. El campo `args` especifica qué añadirá Devin Desktop al comando de inicio. El indicador `--acp` es necesario para iniciar la CLI en modo de servidor ACP y comunicarse con el editor mediante JSON-RPC a través de stdin/stdout. Sin ese indicador, la CLI se inicia en el modo interactivo normal y Devin Desktop no la detecta. Haz una copia de seguridad de `registry.json` antes de editarlo. Un archivo JSON mal formado bloqueará todos los agentes ACP: ```bash cp ~/.windsurf/acp/registry.json ~/.windsurf/acp/registry.json.backup ``` Después, abre el archivo en un editor y añade el bloque del agente al arreglo `agents`. ## Conectar la CLI Codex de OpenAI
Puntos clave Codex CLI se instala mediante npm. Ejecuta `codex auth login` con una clave de API de OpenAI o una suscripción a ChatGPT, añade un bloque a `registry.json` y activa el agente en los ajustes de Devin. Codex es el más rápido de los tres. Es una buena opción para tareas en las que la velocidad y el código de estructura importan más que la calidad del razonamiento.
Primer paso: autentícate. Sin autenticación, la CLI no puede llamar a la API: ```bash codex auth login ``` El comando abre un navegador. Si tienes ChatGPT Plus o Team, la autenticación se realiza mediante tu cuenta y no necesitas una clave de API independiente. Si no tienes una suscripción a ChatGPT, te pedirá una clave de API de platform.openai.com. Segundo paso: comprueba que funciona en el modo normal: ```bash codex run "write hello world in python" ``` Si recibes una respuesta y aparece una entrada en `~/.codex/sessions/`, la CLI funciona correctamente. Ya puedes conectarla al editor. Tercer paso: añade un bloque a `~/.windsurf/acp/registry.json`. Usa la estructura de la sección anterior y completa `path` con el resultado de `which codex`: ```bash which codex # /opt/homebrew/bin/codex ``` Cuarto paso: activa el agente en el editor. Abre la paleta de comandos en Devin Desktop: - `Cmd+Shift+P` en macOS - `Ctrl+Shift+P` en Windows y Linux Ejecuta este comando desde la paleta: `Devin User Settings`. En la ventana que se abre, ve a la pestaña `Agents`. Codex debería aparecer en la lista después de editar el registro. Activa el interruptor que aparece junto a él. Después de activarlo, aparece una nueva columna en Agent Command Center. Puedes asignarle una tarea y Codex la completará. En la prueba descrita aquí, Codex fue el más rápido de los tres: tardó unos 8 segundos en realizar la tarea «añade registro a esta función». Claude tardó 16 segundos en la misma tarea y OpenCode, 22. Codex es adecuado cuando: - Necesitas código estándar rápidamente, sin razonamientos extensos - Estás creando código de estructura y quieres hacer muchos cambios pequeños seguidos - Trabajas a partir de una especificación existente y la solución es evidente Codex no es la mejor opción cuando: - Se trata de una tarea de arquitectura compleja con concesiones: a menudo toma atajos - Necesitas una respuesta equilibrada sobre código delicado desde el punto de vista legal: Claude es una opción mejor - Estás acostumbrado a ajustar prompts con precisión y a aplicar tus propias reglas: las herramientas de Claude son más flexibles ## Conectar Claude Agent de Anthropic
Puntos clave Claude Agent en Devin Desktop combina el binario nativo de Claude Code con el adaptador comunitario de código abierto `claude-agent-acp`. El adaptador ejecuta Claude Code en modo de servidor ACP. La autenticación se realiza mediante una suscripción a Claude Pro o una clave de API de Anthropic. Esta combinación destaca por la calidad de su razonamiento y su buen rendimiento con bases de código grandes.
Anthropic todavía no publica su propio binario ACP con el nombre «Claude Agent». Devin Desktop utiliza lo mismo que Claude Code normal, pero mediante un shim: el adaptador [claude-agent-acp](https://github.com/agentclientprotocol/claude-agent-acp) del repositorio del protocolo, con licencia Apache 2.0. Primer paso: autentica Claude Code: ```bash claude auth login ``` Si tienes una suscripción a Claude Pro o Max, la autenticación se realiza mediante tu cuenta. De lo contrario, te pedirá una clave de API de console.anthropic.com. Segundo paso: compruébalo: ```bash claude "rewrite this function so it returns Result" ``` Si la CLI responde, puedes instalar el adaptador y conectarlo al editor. Tercer paso: instala el adaptador: ```bash npm install -g @agentclientprotocol/claude-agent-acp ``` Cuarto paso: añade un bloque a `registry.json`. El campo `path` señala al binario del adaptador, no a `claude` directamente: ```json { "id": "claude-agent", "name": "Claude Agent", "version": "0.4.0", "description": "Anthropic's coding agent (community ACP adapter)", "authors": ["Anthropic", "ACP community"], "license": "Apache-2.0", "distribution": { "binary": { "darwin-arm64": { "path": "/opt/homebrew/bin/claude-agent-acp", "args": [] } } } } ``` Quinto paso: actívalo en los ajustes de Devin, en la pestaña Agents. En las pruebas descritas aquí, Claude Agent gestionó mejor las tareas más grandes. Para la tarea «divide este componente de 600 líneas en tres archivos, conservando todos los imports y las pruebas», Codex olvidó dos veces que el componente se mostraba en tres lugares. Claude lo detectó todo a la primera. Claude Agent tiene los mismos inconvenientes que Claude Code: - Es más lento que Codex en tareas sencillas - Cada llamada cuesta más si usas la API en vez de una suscripción ¿Quieres que varios agentes de IA trabajen en tu tarea sin que se conviertan en un zoológico de binarios? Conectarlos es la parte técnica. Lo más importante es saber cómo distribuir el contexto entre ellos para que cada agente sepa lo que ya han hecho los demás. Eso forma parte de la ingeniería de contexto: uno de los tres elementos del sistema —un clon de IA de ti, el Segundo Cerebro del proyecto y la ingeniería de contexto para cada tarea—. Después, da igual qué protocolo usen tus agentes para comunicarse: funcionan de la misma manera. ## Conectar OpenCode: una alternativa gratuita
Puntos clave OpenCode es un agente ACP de código abierto creado por una comunidad independiente. Funciona con cualquier API compatible con OpenAI, incluidas las API locales mediante Ollama. Instalarlo y ejecutarlo localmente es gratis. Su punto fuerte es que puedes ejecutarlo completamente sin conexión o con modelos económicos como Qwen.
OpenCode comenzó como una alternativa de código abierto a Claude Code a principios de 2026. En junio, su repositorio había acumulado más de 30.000 estrellas, su documentación se había traducido a una docena de idiomas y había preajustes listos para Ollama y vLLM. Instálalo con el script: ```bash curl -fsSL https://opencode.ai/install | bash ``` Comprueba la instalación: ```bash opencode --version ``` A continuación, configura el modelo que utilizará OpenCode. Para ejecutarlo íntegramente en local, inicia Ollama e indica a OpenCode que lo use: ```bash opencode config set provider ollama opencode config set base_url http://localhost:11434 opencode config set model qwen3.5-coder:32b ``` [Buscar guías de herramientas en la documentación de Ailoot](https://ailoot.ai/docs/) Después, añade un bloque a `registry.json`: ```json { "id": "opencode", "name": "OpenCode", "version": "0.18.1", "description": "Open source coding agent", "authors": ["OpenCode community"], "license": "MIT", "distribution": { "binary": { "darwin-arm64": { "path": "/usr/local/bin/opencode", "args": ["acp"] } } } } ``` Actívalo en los ajustes de Devin. Listo. En las pruebas descritas aquí, OpenCode con Qwen 3.5 Coder respondió notablemente más despacio que Codex y Claude: una media de 22–25 segundos por tarea, frente a los 8–16 de sus competidores. Por otro lado, no cuesta nada y ningún equipo detrás de él puede revocarte el acceso. OpenCode es adecuado cuando: - Tienes una GPU local y quieres realizar tareas de programación sin conexión - Estás trabajando en un proyecto de aprendizaje y todavía no quieres gastar dinero en una API - Quieres comparar el retraso de los modelos de código abierto frente a los cerrados OpenCode no es la mejor opción cuando: - Necesitas una calidad cercana a la de Claude; los modelos de código abierto aún no están a su altura - Se trata de tareas de arquitectura grandes con un contexto de más de 50K tokens; los modelos locales suelen perder el hilo - La velocidad es fundamental; incluso en una 4090, OpenCode es más lento que Codex en la nube ## Spaces: compartir el contexto entre agentes
Puntos clave Spaces son grupos de Devin Desktop en los que los agentes pueden ver el contexto de los demás. Usa un Space por proyecto. Si Codex escribe una prueba allí, Claude sabrá exactamente de qué prueba se trata sin que tengas que explicárselo de nuevo. Disponible en el plan Pro.
Antes, cada agente de Windsurf tenía su propia sesión. Iniciabas Cascade y luego Codex, y no sabían nada el uno del otro. Cognition solucionó esto con Spaces.

Creamos Spaces para que los agentes que trabajan juntos pudieran compartir contexto y colaborar eficazmente en las tareas.

— Blog de Cognition, https://cognition.ai/blog/introducing-devin-desktop
Dentro de un Space, los agentes pueden ver: - Los cambios en archivos realizados por otros agentes - El historial de las tareas y decisiones recientes - El contexto compartido de los prompts (por ejemplo, tu `CLAUDE.md` o `AGENTS.md`) - Las solicitudes de cambios en curso y sus comentarios Para crear un Space: 1. Abre Agent Command Center (el botón de la barra superior de Devin Desktop) 2. Haz clic en «New Space», en la esquina superior derecha 3. Vincula una carpeta del proyecto al Space 4. Añade los agentes que necesites de entre los activados en los ajustes Un flujo de trabajo práctico para una configuración con tres agentes: 1. **Codex** escribe el primer borrador de la implementación en el Space 2. **Claude Agent** ve lo que ha hecho Codex y revisa el código, refactoriza y limpia las partes complicadas 3. **OpenCode** escribe las pruebas de la versión final Los tres usan el mismo `AGENTS.md` (un archivo compartido con las reglas del proyecto) y el mismo archivo de tarea. No hace falta repetir el contexto. Las pruebas en tres proyectos mostraron dos cosas. Primero, el tiempo desde que se inicia una tarea hasta que se completa una solicitud de cambios se redujo aproximadamente en un tercio, porque los agentes no tenían que repetirse información entre sí. Segundo, hizo falta más intervención manual porque Codex y Claude a veces orientaban el código en direcciones distintas. Conviene redactar `AGENTS.md` con precisión. Si todavía no tienes tu propio `AGENTS.md`, consulta la guía [Cómo usar AGENTS.md y CLAUDE.md juntos](https://ailoot.ai/blog/es/agents-md-claude-md-one-instruction-file/): describe un único archivo de instrucciones que leen los tres agentes. ## ¿Cuándo conviene usar cada agente?
Puntos clave Cinco situaciones prácticas para alternar entre Codex, Claude Agent y OpenCode en Devin Desktop. Cada situación es una decisión de negocio, no una comparación de modelos.
**Patrón 1. Una funcionalidad estándar en 30 minutos** CRUD para una tabla nueva, un formulario con dos campos, una página web sencilla. Elige Codex. La escribirá en 5 minutos y podrás revisarla y entregarla. Claude tardará demasiado en pensar. OpenCode no será lo bastante rápido. **Patrón 2. Una tarea de arquitectura con concesiones** Tienes que decidir si extraer esta parte a un servicio independiente o mantenerla en el monolito. O elegir entre Redux y Zustand para un proyecto existente. Elige Claude. Puede sopesar los argumentos. Codex te dará una «solución» sin debatirlo y lo más probable es que sea incorrecta. **Patrón 3. Cobertura de pruebas para código ya escrito** Después de que uno de los agentes escriba el código, cambia a Claude o OpenCode para las pruebas. Codex no suele tener buen criterio para identificar qué casos límite importan. Claude supera a los demás al probar lógica de negocio compleja, mientras que OpenCode es bueno escribiendo pruebas de integración de API. **Patrón 4. Desarrollo local sin conexión** Un avión, un tren, una casa de campo sin Internet. Codex y Claude no funcionarán: requieren una API. OpenCode con Ollama y un modelo local es la única opción. La calidad es menor, pero aun así puedes escribir código. **Patrón 5. Comparar tres respuestas** Si no tienes claro qué enfoque es el adecuado, asigna la misma tarea a los tres agentes mediante Spaces. Compara las tres respuestas y elige la mejor o combínalas. Cuesta más tokens, pero compensa en las tareas críticas. En el ritmo de trabajo descrito aquí, el 60 % de las tareas se asignan a Codex (velocidad), el 30 % a Claude (calidad) y el 10 % a OpenCode (sin conexión). En este ejemplo, una vez por semana se inician los tres en Spaces para abordar una tarea difícil y comparar sus propuestas. ## Planes de Devin Desktop y suscripciones a los agentes
Puntos clave Los agentes ACP solo están habilitados en Pro (20 $ al mes), Max (200 $) o Teams (80 $ por equipo más 40 $ por miembro). Las suscripciones a los propios agentes (OpenAI, Anthropic) son independientes.
Una vez que pagues Devin Desktop, cada agente ACP necesitará su propia suscripción: - **Codex** — ChatGPT Plus o Team (desde 20 $), o una clave de API de OpenAI con pago por uso - **Claude Agent** — Claude Pro (20 $) o Max, o una clave de API de Anthropic. - **OpenCode** — gratis si se usa un modelo local mediante Ollama. El mínimo ético es no compartir una cuenta entre varias personas; cada cuenta está registrada a nombre de una persona. En junio de 2026, las suscripciones básicas para una configuración con los tres agentes suman unos 60 $ al mes: Devin Pro (20 $), ChatGPT Plus (20 $) y Claude Pro (20 $). Si reduces la configuración a Codex y OpenCode sin Claude, cuesta 40 $. ## ¿En qué se diferencia ACP de MCP?
Puntos clave ACP conecta un editor con un agente. MCP conecta un agente con una herramienta (base de datos, archivos, API). Un agente se comunica con el editor mediante ACP y se conecta a las herramientas que necesita para una tarea mediante MCP. Los estándares se complementan; no compiten entre sí.
A menudo se confunden porque ambos son «protocolos para agentes» y ambos usan JSON-RPC. La diferencia está en lo que conectan. **MCP —Model Context Protocol—**, de Anthropic, conecta un agente con fuentes de datos y herramientas. A través de un servidor MCP, un agente puede consultar tu base de datos, leer archivos, llamar a la API de GitHub y acceder a Notion. Analiza los datos de entrada y decide qué herramienta utilizar. **ACP —Agent Client Protocol—**, de Zed y JetBrains, conecta un editor con un agente. Mediante ACP, un IDE transmite al agente el código que has seleccionado, los archivos que has abierto y el comando que has ejecutado desde la paleta. A cambio, recibe cambios en archivos, solicitudes de confirmación y el progreso de las tareas. Un agente se comunica con el editor mediante ACP y con sus herramientas mediante MCP. La pila tiene este aspecto: ``` ┌─────────────────┐ │ Devin Desktop │ ← editor └────────┬────────┘ │ ACP (Apache 2.0, JSON-RPC sobre stdio) ┌────────▼────────┐ │ Claude Agent │ ← agente └────────┬────────┘ │ MCP (Anthropic, JSON-RPC sobre HTTP o stdio) ┌────────▼────────┐ │ MCP server │ ← herramienta (base de datos, archivos, API) └─────────────────┘ ``` Para saber más sobre MCP, consulta la guía independiente [Servidores MCP para Claude Code](https://ailoot.ai/blog/es/mcp-servers-claude-code/), que incluye ejemplos para conectar siete servidores listos para usar. ## ¿Qué no funciona en junio de 2026?
Puntos clave En junio de 2026, ACP está en producción en Devin Desktop, pero tiene limitaciones. La principal es que el registro no descarga agentes automáticamente, por lo que tienes que instalar las CLI manualmente. Entre las limitaciones menores, algunas funciones avanzadas del editor solo funcionan con Devin Local, no con todos los agentes ACP.
Tres limitaciones destacadas durante dos semanas de pruebas: **El registro no descarga agentes.** Como se indicó al principio de esta guía, Devin Desktop espera que instales los binarios CLI manualmente. Un script de instalación puede resolverlo, pero las guías suelen olvidarse de mencionarlo. **No todas las funciones del editor se transmiten a todos los agentes.** La edición de varios archivos en una sola transacción actualmente solo funciona por completo con Devin Local. Codex y Claude mediante ACP reciben los comandos de edición de uno en uno, un archivo cada vez. Esto no interfiere con la mayoría de las tareas, pero si una refactorización abarca 5 archivos o más en una sola operación, tienes que volver a Devin Local. **Conflictos al trabajar en paralelo.** Si dos agentes editan el mismo archivo al mismo tiempo en un Space, el último en escribir sobrescribe la versión del otro. Devin Desktop todavía no muestra una comparación de conflictos. La solución es asignar un archivo diferente a cada agente en la tarea o trabajar mediante una solicitud de cambios y resolver manualmente los conflictos de fusión. JetBrains señala limitaciones beta similares en su implementación de ACP en IDE 25.3 RC: Es el mismo patrón que en Devin Desktop: instala la CLI manualmente y conéctala en el editor. ## ¿Hacia dónde se dirige el ecosistema?
Puntos clave El registro de agentes compatibles con ACP crece cada mes. En marzo de 2026, el ecosistema contaba con más de 25 agentes; en junio, zed.dev/acp incluía más de 60. Se espera una consolidación para finales de 2026: Cursor, Replit Agent, Continue y Aider también podrían anunciar compatibilidad con ACP. Devin Desktop seguirá siendo un editor dentro de una lista más amplia, no el único.
ACP es actualmente uno de los estándares líderes, pero no el único. Hay tres que crecen en paralelo: - **MCP** (Anthropic): de agente a herramienta. Ya es el estándar de facto. - **A2A** (Google, abril de 2025): de agente a agente. Comunicación entre agentes independientes sin un coordinador central. - **ACP** (Zed, JetBrains, finales de 2025): de editor a agente. Se espera que en los próximos meses Cursor y Replit Agent integren ACP en sus interfaces. Actualmente usan API propietarias. Cuando dos grandes actores adopten ACP, el estándar se generalizará. Entonces, «tu propio agente en cualquier editor» se convertirá en una práctica habitual. Para quien programa con IA, esto significa dos cosas. Primero, no necesitas instalar cinco aplicaciones distintas para probar modelos nuevos. Segundo, si un proveedor cambia mañana su modelo de precios o cierra, puedes trasladar su agente a cualquier editor ACP y seguir trabajando. Configurar un trío de agentes es la parte técnica. Entender cómo afectan las decisiones técnicas a tu producto es otra habilidad. La tarea principal consiste en crear un sistema en el que la IA reproduzca tu forma de pensar (un clon de IA), recuerde el contexto del proyecto (un Segundo Cerebro) y lea las reglas de la tarea (ingeniería de contexto). Estos tres elementos forman un sistema funcional. Después, puedes cambiar de herramientas en una tarde.
### Fuentes - [Agent Client Protocol en GitHub — especificación v1](https://github.com/agentclientprotocol/agent-client-protocol) - [Catálogo de agentes y editores ACP en zed.dev](https://zed.dev/acp) - [Documentación de Devin Desktop sobre ACP](https://docs.devin.ai/desktop/acp) - [Blog de Devin — anuncio de Devin Desktop y ACP, 2 de junio de 2026](https://devin.ai/blog/windsurf-is-now-devin-desktop) - [Blog de Cognition — Spaces y Agent Command Center](https://cognition.ai/blog/introducing-devin-desktop) - [JetBrains — página de ACP](https://www.jetbrains.com/acp/) - [OpenCode — agente ACP de código abierto](https://opencode.ai)
Conoce [Ailoot](https://ailoot.ai/). ## Preguntas sobre Claude, Codex y Devin ### ¿Por qué no aparece un agente después de editar registry.json? Comprueba que su CLI esté instalada, que la ruta del registro apunte al ejecutable real y que esté activado en Devin Settings → Agents. El registro describe cómo arrancar una herramienta; no la instala ni autentica. ### ¿ACP sustituye a MCP? No. ACP conecta el editor con el agente; MCP conecta el agente con herramientas y fuentes de datos. Un agente puede usar ACP para interactuar con el editor y MCP para una base de datos u otra herramienta en el mismo trabajo. ## Ailoot · La empresa y su cartera de proyectos Ailoot se apoya en la experiencia operativa acumulada, una amplia base de clientes, un servicio estable y el seguimiento continuo de KPI. La empresa y su cartera de proyectos: millones de clientes; ventas por miles de millones al mes. Ailoot aplica esa experiencia operativa al acceso por API a funciones de IA en productos de clientes, agentes, aplicaciones y automatizaciones.