OpenCode: así es el agente de IA para código que habla el idioma de desarrolladores y sysadmins

Mientras la mayoría de “copilotos” de IA viven dentro de IDEs pesados o en el navegador, OpenCode va a contracorriente: es un agente de código pensado para el terminal, open source y proveedor-agnóstico. Justo el tipo de herramienta que encaja en el flujo de trabajo de quienes viven entre ssh, tmux, monorepos y servidores remotos.

Un agente de IA que no te saca del terminal

OpenCode se presenta como “the open source coding agent built for the terminal”. No es otro chat más: es una TUI (interfaz de texto) que se instala como binario y se ejecuta directamente desde la consola, integrándose con tu editor y tu árbol de proyectos.

Su filosofía es clara:

• Todo desde el terminal: pensado por y para usuarios de Neovim y demás entornos keyboard-driven.
• 100 % open source: el cliente es auditable y extensible, sin cajas negras.
• Sin casarse con nadie: soporta distintos proveedores de LLM (OpenAI, Claude, Google, modelos locales…), y la elección del modelo es configurable.

Para el desarrollador o el sysadmin que ya trabaja en servidores, contenedores o WSL, es mucho más natural invocar un agente de IA desde la misma sesión donde compila, aplica terraform o revisa logs.

Instalación pensada para entornos reales

A diferencia de otros proyectos que solo publican un binario suelto, OpenCode cuida bastante la parte de despliegue:

• Script rápido tipo curl | bash para pruebas rápidas: curl -fsSL https://opencode.ai/install | bash
• Soporte para gestores de paquetes:
  • npm i -g opencode-ai@latest
  • brew install opencode
  • choco install opencode (Windows)
  • scoop install opencode
  • paru -S opencode-bin (Arch)
  • nix run nixpkgs#opencode o vía flake.

Además, respeta variables como OPENCODE_INSTALL_DIR o XDG_BIN_DIR, algo que agradece cualquiera que mantenga dotfiles o entornos homogéneos en varios equipos.

En resumen: no es un juguete de laboratorio; se puede desplegar razonablemente bien en entornos de desarrollo serios o incluso en máquinas de bastionado que usas para trabajar contra producción.

Dos agentes principales: build y plan

Una vez dentro de la TUI, OpenCode funciona con la idea de “agentes”:

• build
  Es el agente por defecto. Tiene acceso completo:
  • Lee y edita ficheros.
  • Puede crear nuevos archivos y refactorizar código.
  • Ejecuta comandos de shell cuando hace falta (tests, linters, builds).
  Es el modo pensado para desarrollo activo, refactors grandes y trabajo del día a día.
• plan
  Es un agente orientado a análisis:
  • Solo lectura por defecto.
  • Pregunta antes de ejecutar comandos de shell.
  • Ideal para:
    • Explorar código legado.
    • Entender monorepos enormes.
    • Diseñar cambios antes de tocar nada.

Puedes alternar entre agentes con la tecla Tab, y existe además un sub-agente @general para búsquedas complejas y tareas multi-paso (por ejemplo: “encuentra todos los sitios donde gestionamos sesiones, resume el patrón y propón una nueva API común”).

Para un sysadmin o SRE, el modo plan es especialmente útil para auditar scripts, playbooks o manifests sin arriesgarse a que nada se ejecute sin control.

Provider-agnostic, con LSP y arquitectura cliente/servidor

OpenCode no intenta ser “otro chat más” sino una capa de orquestación:

• Provider-agnostic
  Puedes configurarlo para usar:
  • OpenAI
  • Anthropic
  • Google
  • Otros proveedores compatibles
  • Incluso modelos locales si expones una API compatible.
  Eso permite ajustar coste, latencia y privacidad según el entorno: desde el portátil personal con un modelo remoto hasta un entorno on-prem con LLM privado.
• Soporte LSP out-of-the-box
  Integra servidores de lenguaje, lo que mejora la comprensión de tipos, símbolos y referencias. Para el agente, el proyecto no es solo texto plano: tiene contexto semántico.
• Arquitectura cliente/servidor
  El binario no es solo una TUI monolítica:
  • El servidor puede residir en tu máquina o en un host remoto (por ejemplo, una workstation con buena GPU o acceso a la red interna).
  • El cliente puede ser la interfaz TUI… o cualquier otro front-end que se construya encima (en el futuro, apps móviles, web, etc.).

Para desarrolladores que trabajan con ssh a máquinas remotas, esto encaja muy bien: el servidor de OpenCode vive junto al código y los toolchains, y tú te conectas desde donde quieras.

Qué aporta a desarrolladores

Para un desarrollador acostumbrado a la terminal, OpenCode cubre varios casos de uso interesantes:

• Refactors grandes con contexto completo
  No se limita al fichero abierto: puede recorrer el árbol, entender dependencias y proponer cambios consistentes.
• Onboarding acelerado
  En proyectos legacy, pedir: “Explícame cómo fluye una petición HTTP desde el entrypoint hasta la capa de datos” deja de ser una eternidad de grep y rg, y pasa a ser una respuesta guiada con enlaces a los ficheros concretos.
• Generación y mejora de tests
  Proponer baterías de tests unitarios o de integración a partir del código existente, con capacidad para ejecutarlos y ajustar hasta que pasen.
• Automatización repetitiva
  Tareas tipo:
  • “Añade logging estructurado a todos los handlers de esta carpeta”.
  • “Migra esta API de requests a httpx en todo el módulo”.
  pasan de ser trabajos mecánicos a acciones guiadas por el agente, siempre con revisión humana final.

Y qué aporta a sysadmins y SRE

Para perfiles de sistemas, DevOps o SRE, el valor está en otro punto:

• Revisión y generación de scripts
  Bash, PowerShell, Python utilitario… OpenCode puede:
  • Analizar scripts de mantenimiento.
  • Proponer mejoras (manejo de errores, idempotencia).
  • Migrar fragmentos a herramientas más modernas (por ejemplo, de scripts sueltos a Ansible o Terraform, según el caso).
• Infraestructura como código
  Ayuda a:
  • Entender módulos de Terraform complejos.
  • Comparar manifests de Kubernetes y detectar incoherencias.
  • Proponer estrategias de refactor para homogeneizar clusters, pipelines, etc.
• Entornos remotos y troubleshooting
  Al vivir en el terminal, es muy cómodo usarlo en:
  • Bastion hosts.
  • Entornos de staging.
  • Máquinas de laboratorio.
  Siempre con la precaución obvia: el agente puede proponer comandos, pero la decisión de ejecutarlos (y cómo) sigue siendo tuya.

El modo plan se presta especialmente a auditoría y análisis de riesgo: revisar playbooks, políticas de seguridad o scripts de backup antes de tocarlos.

No es magia: todavía hace falta criterio técnico

Como cualquier agente basado en LLM, OpenCode no reemplaza el criterio de un desarrollador o un sysadmin experimentado. Sigue habiendo riesgos conocidos:

• Puede alucinar comandos o parámetros que no existen.
• No “entiende” realmente:
  • Topología de red.
  • SLAs.
  • Reglas internas de tu organización.

Por eso, el valor real aparece cuando se combina con buenas prácticas:

• Revisar siempre diffs antes de aplicar cambios.
• Controlar las claves y secretos que se exponen al agente.
• Configurar límites claros sobre qué puede leer y dónde puede escribir.

Un nuevo eslabón en la caja de herramientas del terminal

Para quienes programan y administran sistemas desde la consola, OpenCode es una propuesta muy interesante: un agente de IA que no te obliga a cambiar de editor, ni de flujo de trabajo, ni de proveedor de modelos.

No pretende competir con IDEs completos como VS Code en comodidad “para todos los públicos”, sino ofrecer potencia y flexibilidad justo donde los desarrolladores y sysadmins más avanzados se sienten cómodos: el terminal, el teclado y el control fino de lo que ocurre en cada comando.

Si ya usas IA para programar pero echas de menos una herramienta que encaje mejor en tu mundo de shells, multiplexores y servidores remotos, OpenCode merece claramente un hueco en tu siguiente sesión de pruebas.