opencode: agentes de IA en tu terminal

Esta guía no es teórica. Es exactamente el setup que uso todos los días: un agente orquestador fuerte que planea y decide, y un modelo ejecutor rápido y barato que hace el trabajo pesado de editar código. Si quieres saltarte el marketing de los agentes de IA, esto es lo que de verdad importa: el costo y la velocidad.

1 ¿Qué es opencode?

opencode es un agente de IA open-source para desarrollo que corre en tu terminal. Piensa en Claude Code pero:

• Open-source — el código está en GitHub (anomalyco/opencode, ~195K estrellas).
• Multi-proveedor — usa Claude, OpenAI, DeepSeek, cualquier modelo. No estás atado a un vendor.
• Multi-agente — agentes especializados (build, plan, debug) y configuración por agente.
• Plan gratis real — con opencode Go te regalan crédito para empezar.
• Cualquier terminal — es un binario. Corres opencode y listo, sin IDE.

Es un agente agentic: lee tu código, usa tool calling (edita archivos, corre comandos, consulta el repo) y trabaja contigo en ciclos. No es un chatbot: es un ingeniero junior que no se cansa.

2 Instalación y primeros pasos

Paso 1: instala

curl -fsSL https://opencode.ai/install | bash

También disponible vía npm (npm install -g opencode-ai), Homebrew (brew install anomalyco/tap/opencode) o binarios desde GitHub Releases.

Paso 2: conéctate a un proveedor

Dentro de opencode usa /connect para conectar proveedores (opencode, Anthropic, OpenAI, etc.) o configura tu API key en opencode.json:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "anthropic": { "apiKey": "sk-ant-..." },
    "opencode-go": { "apiKey": "oc-go-..." }
  }
}

Paso 3: verifica

• opencode --version — confirma que el binario quedó instalado.
• opencode en la raíz de tu proyecto — arranca la TUI.
• /init — opencode analiza tu repo y genera AGENTS.md (las reglas de trabajo para el agente).
• Escribe tu primer prompt: "¿cómo está estructurado este proyecto?".

3 Modelos y orquestación — LA PARTE CENTRAL

Aquí está la idea que cambia tu flujo de trabajo. No necesitas un modelo para todo. Necesitas dos:

Cómo se combinan

El orquestador usa tool calling: no "piensa" cada línea, sino que delega tareas de ejecución al modelo rápido. Flujo real:

┌──────────────────────────────────────────────────────────────┐
│                    TU PROMPT                                  │
│         "Agrega login con JWT al endpoint /auth"              │
└──────────────────────────┬───────────────────────────────────┘
                           ▼
┌──────────────────────────────────────────────────────────────┐
│              AGENTE ORQUESTADOR  (fuerte, caro)               │
│        anthropic/claude-opus-5 · ~10 llamadas totales         │
│                                                              │
│  1. Lee el repo, entiende el stack                          │
│  2. Decide: "crear middleware → ruta /auth → tests"          │
│  3. Delega cada subtarea al ejecutor                         │
└──────────────────────────┬───────────────────────────────────┘
                           ▼
┌──────────────────────────────────────────────────────────────┐
│               MODELO EJECUTOR  (rápido, barato)               │
│       opencode-go/deepseek-v4-flash · ~200 llamadas           │
│                                                              │
│  · escribe auth.middleware.js                                │
│  · escribe la ruta /auth/login                               │
│  · corre los tests, corrige errores                          │
└──────────────────────────────────────────────────────────────┘

Comparativa de modelos

4 Comandos para cambiar de modelo

Todo dentro de la TUI, con la barra /:

Cambiar el modelo del agente activo

Cuando estás en un agente (p. ej. build), /models cambia el modelo de ese agente. Es decir: puedes tener cada agente con su modelo propio. Setup que yo uso:

{
  "$schema": "https://opencode.ai/config.json",
  "model": "opencode-go/deepseek-v4-flash",
  "agents": {
    "orchestrator": { "model": "anthropic/claude-opus-4" },
    "executor": { "model": "opencode-go/deepseek-v4-flash" }
  }
}

Forzar modelo en el prompt

Escribe @model en tu mensaje para forzar el modelo de ese turno, sin tocar la configuración:

@model anthropic/claude-opus-5
Analiza esta arquitectura y dime qué refactor harías. No edites nada aún.

Perfecto para usar el orquestador solo cuando lo necesitas: planear con Opus, ejecutar con DeepSeek V4 Flash.

5 opencode Go: agentes gratis (o casi)

opencode Go es el plan de pago (barato) de opencode: modelos de calidad probados para coding agéntico, con límites generosos y acceso confiable. Y al registrarte con mi link te regalan $5 USD de crédito:

Modelos incluidos en Go

Cómo configurarlo

1. Regístrate en opencode.ai/go (te dan los $5 con el código FC5A91NW61).
2. Copia tu API key desde opencode.ai/auth.
3. Pégalo en opencode con /connect → selecciona opencode.

Si configuras a mano:

{
  "$schema": "https://opencode.ai/config.json",
  "model": "opencode-go/deepseek-v4-flash",
  "provider": {
    "opencode": { "apiKey": "oc-..." }
  }
}

6 ¿Y entonces por qué no uso Claude Code?

Buena pregunta. Claude Code es un gran producto, y opencode se inspira en él. La diferencia es dónde te deja parado:

7 Comandos diarios útiles

El kit diario que de verdad usas cuando ya estás trabajando:

Plan mode: el hábito que te ahorra rehacer todo

Presiona Tab para alternar entre Build mode (edita archivos) y Plan mode (solo analiza y propone). Regla que me ahorra horas:

• Features grandes → primero Plan mode, revisa el plan, y recién ahí cambia a Build.
• Features chicas → directo a Build.

opencode                  # en la raíz del proyecto
/init                     # primera vez: genera AGENTS.md
@model opencode-go/deepseek-v4-flash   # ejecutor rápido por defecto
[TAB] → plan mode        # "agrega auth JWT a /auth: hazme un plan"
[TAB] → build mode       # "ok, ejecútalo"
/compact                  # si la conversación se alarga, compáctala

Buenas prácticas de prompt

• Contexto por defecto: el @ para referenciar archivos: explica @src/api/index.ts.
• Habla como a un junior: da contexto, ejemplos y criterios de éxito.
• Específico > general: "refactoriza el handler en @routes/auth.js para usar async/await" funciona mejor que "arregla el código".
• Itera: el agente hace, tú revisas el diff, corriges, repites.