Guía completa de OpenCode: instalación, configuración de Gemini y Ollama, comandos esenciales, caso real paso a paso y comparativo con otras herramientas. Sin costo.

OpenCode es un agente de codificación con inteligencia artificial que opera directamente en la terminal, como aplicación de escritorio o como extensión de editor. A diferencia de herramientas de pago, su modelo de código abierto permite conectar proveedores gratuitos como Google Gemini o ejecutar modelos locales sin gastar nada. Su flexibilidad para trabajar con más de 75 proveedores de modelos de lenguaje lo convierte en una de las opciones más versátiles disponibles hoy para desarrolladores independientes, equipos pequeños y proyectos con restricciones de presupuesto.

¿Qué es OpenCode y cómo funciona?

OpenCode es un agente de código abierto desarrollado por Anomaly que se integra con el entorno de trabajo del desarrollador: lee la estructura del proyecto, entiende el historial de Git y ejecuta cambios sobre los archivos directamente desde la interfaz de terminal. La herramienta está disponible para macOS, Windows y Linux, y su arquitectura modular permite cambiar de modelo de lenguaje en tiempo real sin reiniciar la sesión. El proyecto es mantenido activamente por la comunidad en GitHub, lo que garantiza actualizaciones frecuentes y corrección de errores continuos.

El sistema admite tres modos de uso principales que se adaptan al flujo de trabajo de cada desarrollador:

• Interfaz de terminal interactiva: La experiencia principal, con navegación por teclado y vista de cambios en tiempo real.
• Aplicación de escritorio: Versión gráfica para quienes prefieren no depender de un emulador de terminal avanzado.
• Extensión para editores: Integración disponible para Visual Studio Code y Neovim, sin necesidad de salir del entorno de edición habitual.

¿Cómo instalar OpenCode paso a paso?

La documentación oficial ofrece varios métodos de instalación según el sistema operativo. El más rápido en macOS y Linux es el guión de instalación automática:

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

Una vez terminado, verifica la instalación con:

opencode --version

Si se prefiere instalar mediante gestores de paquetes, estas son las opciones verificadas:

• Node.js (multiplataforma):

  npm install -g opencode-ai

• Homebrew (macOS y Linux):

  brew install anomalyco/tap/opencode

• Arch Linux (versión estable):

  sudo pacman -S opencode

• Arch Linux (última versión desde AUR):

  paru -S opencode-bin

Instalación en Windows

Para Windows, la documentación oficial recomienda usar el subsistema de Linux para obtener el mejor rendimiento. También existen instaladores nativos verificados:

• Chocolatey:

  choco install opencode

• Scoop:

  scoop install opencode

• Docker:

  docker run -it --rm ghcr.io/anomalyco/opencode

Para la interfaz de terminal en cualquier plataforma, la documentación recomienda un emulador moderno como WezTerm, Alacritty, Ghostty o Kitty para aprovechar el renderizado completo de la interfaz.

¿Cómo usar OpenCode sin pagar nada?

OpenCode requiere conectar al menos un proveedor de modelo de lenguaje para funcionar. Existen tres rutas completamente gratuitas y verificadas:

• OpenCode Zen: Lista de modelos curados por el equipo de OpenCode, accesibles mediante el comando /connect dentro de la interfaz. Requiere crear una cuenta gratuita en opencode.ai/auth. Es la opción recomendada para quienes comienzan.
• Google Gemini (nivel gratuito): Crea una clave de interfaz de programación gratuita en aistudio.google.com, agrégala en OpenCode mediante /connect y selecciona Gemini como proveedor.
• Ollama (modelos locales): Instala Ollama por separado y conecta modelos como Llama 3, Mistral o Qwen directamente desde tu máquina. Sin conexión a internet, sin registro externo, con límite práctico determinado por la memoria disponible del equipo.

¿Cómo conectar Google Gemini como proveedor gratuito?

El nivel de acceso gratuito de Google Gemini es suficiente para proyectos personales y uso moderado. El proceso requiere obtener una clave de acceso desde Google AI Studio y registrarla en OpenCode.

Paso 1: obtener la clave de acceso

1. Ingresar a aistudio.google.com con una cuenta de Google.
2. Hacer clic en Get API key en el menú lateral izquierdo.
3. Seleccionar Create API key y elegir un proyecto de Google Cloud existente o crear uno nuevo.
4. Copiar la clave generada. Tiene el formato AIzaSy... y no debe compartirse públicamente.

El nivel gratuito incluye acceso a modelos como Gemini 2.0 Flash y Gemini 1.5 Pro con límites de solicitudes por minuto y por día. Para proyectos con uso intensivo puede ser necesario activar la facturación, aunque el nivel gratuito no requiere tarjeta de crédito en la mayoría de regiones.

Paso 2: registrar la clave en OpenCode

La forma más directa es mediante la interfaz interactiva:

1. Abrir OpenCode con el comando opencode en la terminal.
2. Ejecutar el comando /connect dentro de la interfaz.
3. Seleccionar Google de la lista de proveedores disponibles.
4. Pegar la clave de acceso cuando se solicite.
5. Seleccionar el modelo deseado, por ejemplo gemini-2.0-flash.

La segunda forma es mediante variable de entorno, útil para entornos automatizados:

export GOOGLE_API_KEY="AIzaSy..."

OpenCode detecta esta variable automáticamente al iniciarse. En Windows, desde PowerShell:

[System.Environment]::SetEnvironmentVariable("GOOGLE_API_KEY","AIzaSy...","User")

¿Cómo integrar Ollama para modelos locales sin costo?

Ollama permite ejecutar modelos de lenguaje directamente en el equipo del desarrollador, sin enviar datos a servidores externos. El límite práctico no es de solicitudes sino de recursos del equipo: los modelos más capaces requieren al menos 8 GB de memoria disponible, y el rendimiento mejora considerablemente con tarjeta gráfica dedicada.

Paso 1: instalar Ollama

• macOS y Linux:

  curl -fsSL https://ollama.com/install.sh | sh

• Windows: Descargar el instalador desde ollama.com/download y ejecutarlo.

Verificar que el servicio esté activo con:

ollama --version

Paso 2: descargar un modelo compatible

Para que el agente pueda ejecutar acciones sobre el repositorio, el modelo debe soportar el uso de herramientas externas. Modelos verificados como compatibles con OpenCode:

• Qwen 2.5 Coder 7B — recomendado para equipos con 8 GB de memoria:

  ollama pull qwen2.5-coder:7b

• Qwen 3 8B — generación más reciente con mejor manejo de instrucciones complejas:

  ollama pull qwen3:8b

• Llama 3.1 8B — alternativa de Meta con buen soporte de herramientas:

  ollama pull llama3.1:8b

• Mistral 7B — opción sólida para generación de código en proyectos medianos:

  ollama pull mistral:7b

Paso 3: ampliar la ventana de contexto

Ollama configura por defecto una ventana de contexto de 4,096 unidades, insuficiente para repositorios de tamaño real. Se recomienda crear una variante del modelo con ventana ampliada antes de conectarlo:

ollama run qwen2.5-coder:7b
/set parameter num_ctx 16384
/save qwen2.5-coder:7b-16k
/bye

Sin este paso, el agente pierde información del repositorio durante sesiones largas y genera respuestas incompletas o contradictorias con el código existente.

Paso 4: conectar Ollama con OpenCode

Mediante el archivo de configuración opencode.json en la raíz del proyecto:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      },
      "models": {
        "qwen2.5-coder:7b-16k": {
          "tools": true
        }
      }
    }
  }
}

El parámetro "tools": true es obligatorio para habilitar las acciones autónomas del agente sobre el repositorio. Sin él, OpenCode funciona únicamente en modo conversacional.

¿Ollama en servidor remoto?

Es posible conectar OpenCode a una instancia de Ollama en un servidor propio con mejor capacidad de procesamiento. Solo se cambia la dirección base en el archivo de configuración:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "ollama-remoto": {
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "http://192.168.1.100:11434/v1"
      },
      "models": {
        "qwen2.5-coder:7b-16k": {
          "tools": true
        }
      }
    }
  }
}

Para exponer Ollama en red local, configurar la variable de entorno antes de iniciar el servicio:

OLLAMA_HOST=0.0.0.0 ollama serve

Cabe señalar que exponer Ollama a redes públicas sin autenticación adicional representa un riesgo de seguridad. En entornos con acceso desde internet, se recomienda proteger el puerto mediante un servidor intermediario con autenticación.

Primeros pasos dentro del proyecto

Una vez instalado y configurado el proveedor, el flujo de trabajo es directo. Se navega hasta el directorio del proyecto y se ejecuta opencode para abrir la interfaz interactiva. El primer paso recomendado por la documentación oficial es ejecutar /init, que analiza toda la estructura del repositorio y genera un archivo AGENTS.md en la raíz. Este archivo acumula contexto sobre el código y debe confirmarse en el historial de Git para que persista entre sesiones.

OpenCode opera en dos modos que se alternan con la tecla Tab:

• Modo planificación: El agente propone un plan detallado de cambios antes de modificar cualquier archivo. Útil para revisar el impacto de una instrucción antes de ejecutarla.
• Modo construcción: Aplica cambios directamente sobre los archivos del proyecto de forma autónoma, incluyendo creación, edición y eliminación de código.

Comandos esenciales de la interfaz

Además de la interfaz interactiva, OpenCode expone un modo no interactivo mediante argumentos de línea de comandos, útil para integrarlo en tareas automatizadas:

• opencode — Abre la interfaz interactiva en el directorio actual.
• opencode -p "explica esta función" — Envía un mensaje directo sin abrir la interfaz.
• opencode -m proveedor/modelo — Inicia con un modelo específico.
• /init — Analiza el repositorio y crea o actualiza AGENTS.md.
• /models — Cambia el modelo de lenguaje activo en tiempo real.
• /connect — Conecta un nuevo proveedor o cuenta.
• /undo — Revierte los cambios realizados por el agente.
• /redo — Vuelve a aplicar cambios revertidos.
• /share — Genera un enlace compartible de la conversación actual.

Configuración del archivo opencode.json

Para proyectos donde se requiere un comportamiento consistente, OpenCode permite definir un archivo de configuración opencode.json en la raíz del proyecto. Este archivo controla el modelo predeterminado, las opciones de razonamiento y las variantes de comportamiento por proveedor. Un ejemplo mínimo funcional:

{
  "$schema": "https://opencode.ai/config.json",
  "model": "google/gemini-2.0-flash"
}

La documentación oficial en opencode.ai/docs/models detalla todas las opciones disponibles por proveedor.

Integración con Visual Studio Code y Neovim

OpenCode dispone de integración directa con los dos editores más utilizados en entornos de desarrollo de terminal. Para Visual Studio Code, la extensión oficial permite interactuar con el agente sin abandonar el editor. Para Neovim, existe el complemento opencode.nvim compatible con el gestor de complementos lazy.nvim, que permite compartir el contenido del archivo abierto como contexto del mensaje. Ambas integraciones son de código abierto y gratuitas.

Casos de uso reales: para qué sirve OpenCode en proyectos concretos

OpenCode no es una herramienta de sugerencia de código línea por línea como las extensiones tradicionales de editor. Su modelo de agente autónomo lo hace especialmente útil en situaciones donde el desarrollador necesita delegar tareas completas sobre un repositorio. Estos son los escenarios donde se ha demostrado más efectivo:

Proyectos con restricciones de privacidad o cumplimiento normativo

Equipos que trabajan con datos sensibles —como sistemas médicos o plataformas financieras— no pueden enviar su código fuente a servidores externos sin comprometer su cumplimiento normativo. Con OpenCode conectado a modelos locales mediante Ollama, todo el procesamiento ocurre dentro de la red privada del equipo, sin que ningún fragmento de código salga de la infraestructura propia.

Generación y mantenimiento de pruebas automatizadas

Uno de los usos más extendidos en la comunidad es delegar la escritura de pruebas unitarias a OpenCode. El agente analiza las funciones existentes, identifica los casos límite y genera los casos de prueba correspondientes de forma autónoma. Es especialmente útil en proyectos con baja cobertura de pruebas que necesitan alcanzar un umbral mínimo rápidamente.

Migración y modernización de bases de código heredadas

El agente puede recibir instrucciones como “migra este módulo de Python 2 a Python 3 respetando las pruebas existentes” y ejecutar los cambios sobre múltiples archivos de forma coordinada, generando un resumen de los cambios realizados al finalizar. A diferencia de los asistentes de edición convencionales, OpenCode mantiene el contexto completo del repositorio durante toda la sesión.

Proyectos de código abierto sin presupuesto

Para proyectos mantenidos por voluntarios o equipos pequeños, el costo de herramientas como Cursor o GitHub Copilot puede ser una barrera real. OpenCode resuelve esto mediante el modelo de clave de interfaz de programación propia: el desarrollador paga directamente al proveedor del modelo solo por lo que consume, sin suscripciones mensuales fijas. En combinación con el nivel gratuito de Google Gemini, el costo mensual puede mantenerse en cero para proyectos de uso moderado.

Independencia del proveedor de herramientas

Al ser de código abierto y compatible con clave de interfaz de programación propia, el desarrollador mantiene control total sobre qué modelo usa, cuánto paga y a dónde va su código. Esto elimina el riesgo de dependencia que suponen las suscripciones cerradas, donde un cambio de precio o de política del proveedor puede afectar directamente al equipo de desarrollo.

Caso de uso detallado: construcción de una aplicación web desde cero

El siguiente ejemplo documenta el proceso completo de usar OpenCode para construir una aplicación web funcional partiendo de cero, con Google Gemini como proveedor gratuito. El caso está basado en proyectos reales documentados por la comunidad y es totalmente reproducible en cualquier equipo con conexión a internet.

Punto de partida y objetivo

El objetivo es construir una aplicación web sencilla de gestión de tareas con Python y Flask: lista de tareas con base de datos local, formulario de creación, marcado de completado y eliminación. No se parte de ningún código previo. El directorio está vacío.

Configuración utilizada para este ejemplo:

• Sistema operativo: Ubuntu 22.04
• Proveedor: Google Gemini 2.0 Flash (nivel gratuito)
• OpenCode versión: instalado mediante el guión oficial
• Editor: Visual Studio Code con extensión de OpenCode

Paso 1: preparar el entorno y el directorio

Se crea el directorio del proyecto y se inicializa un repositorio de Git:

mkdir gestor-tareas
cd gestor-tareas
git init

Se abre OpenCode en el directorio:

opencode

Al no existir ningún archivo aún, OpenCode muestra la interfaz de terminal lista para recibir instrucciones. La clave de Gemini ya estaba configurada como variable de entorno, por lo que el proveedor se activa automáticamente.

Paso 2: inicializar el contexto del proyecto

Dentro de la interfaz, se ejecuta:

/init

Dado que el directorio está vacío, OpenCode genera un archivo AGENTS.md mínimo con una plantilla base. Se edita manualmente para agregar contexto relevante:

# AGENTS.md

## Descripción del proyecto
Aplicación web de gestión de tareas construida con Python 3 y Flask.
Base de datos local con SQLite mediante SQLAlchemy.
Interfaz en HTML, CSS básico y JavaScript sin dependencias externas.

## Convenciones
- Python: PEP 8
- Nombres de variables y funciones en español
- Comentarios en español
- Pruebas con pytest

## Restricciones
- Sin dependencias de pago
- Sin frameworks de JavaScript
- Compatible con Python 3.10 o superior

Este archivo se confirma en el repositorio:

git add AGENTS.md
git commit -m "Inicializar contexto del proyecto"

Paso 3: generar la estructura base del proyecto

De vuelta en la interfaz de OpenCode, se activa el modo planificación con la tecla Tab y se envía la primera instrucción:

Crea la estructura completa de una aplicación Flask para gestión de tareas.
Incluye: app.py principal, modelo de base de datos con SQLAlchemy,
plantillas HTML para listar, crear y eliminar tareas,
y un archivo requirements.txt con las dependencias necesarias.

OpenCode responde con un plan detallado antes de tocar ningún archivo:

Planificación:
1. Crear app.py con configuración Flask y rutas principales
2. Crear models.py con el modelo Tarea usando SQLAlchemy
3. Crear templates/base.html con estructura HTML común
4. Crear templates/index.html con lista de tareas
5. Crear templates/crear.html con formulario de nueva tarea
6. Crear requirements.txt con flask, flask-sqlalchemy, pytest

¿Proceder con estos cambios? (s/n)

Se confirma con s. OpenCode cambia automáticamente al modo construcción y genera todos los archivos en segundos. El resultado en el directorio es el siguiente:

gestor-tareas/
├── AGENTS.md
├── app.py
├── models.py
├── requirements.txt
└── templates/
    ├── base.html
    ├── index.html
    └── crear.html

Paso 4: revisar y corregir el código generado

Se revisa el contenido de app.py. El agente generó las rutas correctas pero omitió la ruta de eliminación de tareas. Se envía una instrucción de corrección directa, esta vez en modo construcción sin pasar por planificación:

Agrega la ruta /eliminar/ en app.py que elimine la tarea
correspondiente de la base de datos y redirija al índice.
También agrega el botón de eliminar en templates/index.html.

OpenCode modifica únicamente los dos archivos relevantes. Los demás permanecen intactos. Esta precisión quirúrgica es una de las ventajas más valoradas por la comunidad respecto a los generadores de código que reescriben archivos completos.

Paso 5: generar las pruebas automatizadas

Con la aplicación funcional, se delega la escritura de pruebas:

Analiza app.py y models.py y genera un archivo tests/test_app.py
con pruebas unitarias para todas las rutas usando pytest.
Incluye casos de éxito y casos de error para cada ruta.

OpenCode genera el archivo de pruebas completo, incluyendo la configuración de base de datos temporal para pruebas, casos de creación, listado y eliminación de tareas. Se ejecutan las pruebas:

pip install -r requirements.txt
pytest tests/ -v

Resultado:

tests/test_app.py::test_index_vacio PASSED
tests/test_app.py::test_crear_tarea PASSED
tests/test_app.py::test_listar_tareas PASSED
tests/test_app.py::test_eliminar_tarea PASSED
tests/test_app.py::test_eliminar_tarea_inexistente PASSED

5 passed in 1.24s

Paso 6: refactorización con instrucción en lenguaje natural

Se detecta que el modelo de base de datos no valida que el título de la tarea no esté vacío. Se envía la instrucción:

Agrega validación en la ruta de creación para que no se acepten
tareas con título vacío o con solo espacios en blanco.
Muestra un mensaje de error en el formulario si ocurre.

OpenCode modifica app.py y templates/crear.html de forma coordinada, agregando la validación en el servidor y el mensaje de error en la plantilla. A continuación actualiza las pruebas existentes para incluir el caso de título vacío, sin que se le haya pedido explícitamente. Este comportamiento de actualización proactiva del contexto de pruebas es consistente con el uso del archivo AGENTS.md que define pruebas con pytest como convención del proyecto.

Paso 7: resultado final del proyecto

Al finalizar la sesión, el proyecto tiene la siguiente estructura:

gestor-tareas/
├── AGENTS.md
├── app.py                  ← Rutas Flask completas con validación
├── models.py               ← Modelo Tarea con SQLAlchemy
├── requirements.txt        ← flask, flask-sqlalchemy, pytest
├── templates/
│   ├── base.html           ← Estructura HTML compartida
│   ├── index.html          ← Lista de tareas con botón eliminar
│   └── crear.html          ← Formulario con manejo de errores
└── tests/
    └── test_app.py         ← 6 pruebas, todas pasando

El tiempo total de la sesión fue de aproximadamente 25 minutos, incluyendo revisiones manuales y ajustes. El costo en solicitudes a la interfaz de programación de Gemini fue cero, al mantenerse dentro del límite del nivel gratuito. Vale la pena señalar que este mismo flujo es reproducible con Ollama y Qwen 2.5 Coder en modo completamente local, sin ninguna solicitud a servicios externos.

Agentes especializados: automatizar tareas repetitivas

OpenCode permite crear agentes especializados con instrucciones personalizadas para tareas que se repiten con frecuencia en el equipo. Un agente de revisión de código, por ejemplo, puede configurarse para analizar cualquier archivo y generar un informe estructurado de errores, vulnerabilidades y sugerencias de mejora.

Los agentes se definen mediante archivos en formato de texto plano ubicados en:

• Globales (disponibles en todos los proyectos): ~/.config/opencode/agents/
• Por proyecto: .opencode/agents/

El nombre del archivo se convierte en el identificador del agente. Un archivo llamado revisar.md crea el agente revisar. Para crearlo de forma interactiva desde la interfaz:

/agents new

OpenCode solicita una descripción en lenguaje natural, genera el archivo de configuración correspondiente y permite seleccionar qué herramientas tendrá disponibles el agente. Un ejemplo de agente de revisión de seguridad configurado manualmente:

---
name: revisar-seguridad
description: Analiza el repositorio en busca de vulnerabilidades de seguridad
tools:
  - read_file
  - list_files
---

Actúa como auditor de seguridad de código. Analiza todos los archivos
del repositorio, identifica vulnerabilidades comunes (inyección SQL,
exposición de credenciales, validación insuficiente de entradas),
clasifícalas por severidad y genera un informe estructurado con
sugerencias de corrección específicas para cada caso encontrado.

Para ejecutar el agente sobre el proyecto activo:

opencode -p "@revisar-seguridad analiza el proyecto actual"

Integración con GitHub para automatización en repositorios

OpenCode permite automatizar tareas directamente desde GitHub mediante su integración con GitHub Actions. Una vez configurada, es posible mencionar /opencode o /oc en cualquier comentario de una incidencia o solicitud de cambios para que el agente ejecute tareas dentro del proceso de integración continua del repositorio.

Los eventos soportados por la integración oficial incluyen:

• Comentarios en incidencias o solicitudes de cambios
• Comentarios en líneas específicas de código durante una revisión
• Apertura o actualización automática de incidencias
• Ejecución programada mediante planificador de tareas
• Activación manual desde la interfaz de GitHub Actions

Un caso de uso documentado es la generación automática de pruebas cada vez que se abre una solicitud de cambios: el agente analiza el código modificado, genera las pruebas correspondientes y las agrega a la misma solicitud como comentario o como confirmación adicional. La documentación completa de esta integración está disponible en opencode.ai/docs/github.

Comparativo con otras herramientas de codificación con IA

El ecosistema de asistentes de codificación con inteligencia artificial creció considerablemente en los últimos dos años, y cada herramienta responde a un perfil de usuario distinto. La siguiente tabla compara las opciones más relevantes disponibles en 2026:

La diferencia más relevante entre OpenCode y sus alternativas comerciales no es técnica sino estructural: al ser de código abierto y compatible con clave de interfaz de programación propia, el desarrollador mantiene control total sobre qué modelo usa, cuánto paga y a dónde va su código. Cabe señalar que Aider es la alternativa de código abierto más cercana en filosofía —también gratuita, también de terminal, también compatible con múltiples modelos— con la diferencia de que ofrece una integración con Git más madura, mientras que OpenCode presenta una interfaz de terminal más completa visualmente y soporte para modelos locales más amplio.

¿Qué hacer si OpenCode no abre o da error?

Los problemas más frecuentes en la instalación tienen soluciones directas:

• Comando no reconocido en terminal: Verificar que la ruta de instalación está incluida en la variable de entorno PATH. En instalaciones con guión automático, revisar ~/.opencode/bin o ~/bin.
• Error de permisos en macOS o Linux: Ejecutar chmod +x $(which opencode) o reinstalar con permisos de administrador.
• Interfaz con caracteres incorrectos: El emulador de terminal en uso no soporta el renderizado requerido. Cambiar a WezTerm, Alacritty, Ghostty o Kitty.
• No aparecen modelos disponibles: No se ha configurado ningún proveedor. Ejecutar /connect dentro de la interfaz y seleccionar OpenCode Zen u otro proveedor.
• Conflicto con la versión de Node.js: Se recomienda Node.js 18 o superior. Verificar con node --version y actualizar de ser necesario.
• Ollama no responde desde OpenCode: Verificar que el servicio de Ollama está activo con ollama ps y que el modelo fue descargado correctamente con ollama list.

¿Por dónde empezar hoy mismo?

El camino más rápido para tener OpenCode funcionando sin costo es el siguiente:

1. Instalar con el guión oficial: curl -fsSL https://opencode.ai/install | bash
2. Abrir la interfaz con opencode y ejecutar /connect para activar OpenCode Zen de forma gratuita, o configurar la clave de Google Gemini como variable de entorno.
3. Navegar al directorio de un proyecto existente o nuevo y ejecutar /init para que el agente analice el código y genere el archivo AGENTS.md.
4. Activar el modo planificación con Tab y enviar la primera instrucción en lenguaje natural.

La documentación oficial en opencode.ai/docs cubre cada función en detalle.