OpenCode Zen vs Go: cuál elegir (y si puedes usar los dos)

Zen es saldo prepago. Go cuesta 10 USD al mes desde el primer cargo y Go Plus 40 USD, con más cupo por modelo. Cuándo usar uno, el otro o los dos.

Tabla de Contenidos

Primero, aclaremos los tres nombres que todo el mundo confunde
Tabla comparativa: BYOK, Zen y Go
Qué cabe realmente en 10 dólares
El costo real por turno, para poner las cosas en perspectiva
Mi recomendación: separa el diseño de la ejecución
Elegir la IA según la necesidad y la complejidad
Diez tips prácticos para exprimir el plan Go
Herramientas prácticas que acompañan bien este flujo
Cuándo Go no es la respuesta
Cierre
Preguntas frecuentes
Sigue leyendo
Fuentes

Hay un patrón que veo repetirse entre emprendedores técnicos y equipos pequeños: suscripción a Claude, suscripción a ChatGPT, suscripción a Cursor, créditos sueltos en algún gateway, y una sensación difusa de estar quemando entre 60 y 200 dólares al mes sin saber exactamente en qué. Cuando uno se sienta a mirar la factura, casi siempre descubre lo mismo: el gasto no está en pensar, está en ejecutar. Los tokens no se van en la conversación donde decides la arquitectura; se van en las trescientas iteraciones donde un agente lee archivos, corre tests, corrige un import y vuelve a leer.

Esa distinción —pensar versus ejecutar— es exactamente el hueco que ataca OpenCode Go, un plan de 10 dólares al mes que lleva unos meses cambiando la ecuación de costos para quien sabe usarlo. Este artículo es mi análisis de qué cabe realmente en esos 10 dólares, en qué se diferencia de OpenCode Zen, y por qué mi recomendación final no es "cámbiate a Go", sino algo bastante más matizado: define los specs con el modelo más caro que puedas pagar, y ejecútalos con el más barato que aguante la tarea.

Primero, aclaremos los tres nombres que todo el mundo confunde

OpenCode es un agente de código de terminal, open source, mantenido por Anomaly. Es la herramienta: una TUI donde escribes, un agente que lee tu repositorio, edita archivos, corre comandos y te muestra los diffs. Es gratis y siempre lo ha sido.

OpenCode Zen es otra cosa. Es un gateway de modelos —un intermediario— que el equipo de OpenCode construyó después de encontrarse con un problema real: hay decenas de modelos que dicen servir para programar, pero muy pocos funcionan bien como agentes, y los que funcionan bien dan resultados muy distintos según qué proveedor los sirva. Un mismo modelo puede rendir excelente en un proveedor y mediocre en otro, con la misma etiqueta. Zen es la respuesta a eso: probaron modelos, hablaron con los equipos que los entrenan, negociaron con proveedores para que los sirvieran correctamente, hicieron benchmarks de la combinación modelo/proveedor, y publicaron una lista curada. Se paga por uso, con precios por millón de tokens y sin markup declarado más allá de las comisiones de procesamiento de pago.

OpenCode Go es la suscripción. Cuesta 10 USD al mes desde el primer cargo y da acceso a un catálogo de modelos abiertos, con un tope en dólares por modelo, no un bolsillo único del plan. Go Plus cuesta 40 USD al mes, usa los mismos modelos y sube ese tope. El salto no es un múltiplo único: en la documentación del 29 de septiembre de 2026, GLM-5.3-Flash pasa de 60 a 180 USD y Kimi K2.6 de 60 a 240 USD. No es un plan ilimitado. El primer mes a 5 USD ya no existe, y el programa de referidos terminó.

Actualizado el 30 de septiembre de 2026.

Los tres nombres siguen siendo independientes. Go Plus es un segundo precio del mismo catálogo de Go, no un cuarto producto. Puedes usar OpenCode con tus propias claves de OpenAI o Anthropic y no pagarle un centavo a Zen ni a Go. Puedes usar Zen desde otro agente que no sea OpenCode. Y puedes tener Go y Zen a la vez, que es de hecho lo que yo recomiendo más abajo.

Tabla comparativa: BYOK, Zen y Go

	OpenCode BYOK	OpenCode Zen	OpenCode Go
Modelo de cobro	Gratis (pagas al proveedor)	Pago por uso, prepago con saldo	Suscripción plana
Precio	$0 + lo que gastes en tu API	Según tokens consumidos	$10/mes desde el primer cargo. Go Plus: $40/mes
Catálogo	Cualquier proveedor que soportes	La lista pública de la documentación: Claude, GPT, Gemini, Grok, Qwen, DeepSeek, GLM, Kimi, MiniMax y modelos gratis por tiempo limitado	El catálogo de Go. Incluye Grok 4.7 y 4.6, GLM-5.3 y GLM-5.3-Flash, GPT 6 Luna y GPT 5.6 Luna, Kimi, Qwen, DeepSeek, MiniMax, MiMo y otros. Go Plus usa la misma lista
Modelos frontera	Sí, si pagas la API	Sí. La lista de Zen incluye Claude, GPT, Gemini y Grok, además de modelos abiertos	No incluye Claude, GPT Sol ni Gemini Pro. Sí incluye Grok 4.7, Grok 4.6, GPT 6 Luna y GPT 5.6 Luna, con tope de 15 USD al mes en Go
Límites	Los de tu proveedor	Tu saldo, y un límite mensual de workspace o de miembro si lo configuras	Por modelo: 5 horas = 20 % de su tope, semana = 50 %, mes = 100 %. En Go ese tope es 15, 30 o 60 USD según el modelo
Recarga automática	N/A	Si el saldo baja de $5, recarga $20. Puedes cambiar el monto o desactivarla. Un límite mensual no frena esa recarga	N/A, es tarifa fija
Al agotar el límite	N/A	Recarga o se detiene	Sigues con los modelos gratuitos, o cae a tu saldo Zen si activas "Use balance"
Equipos	Manual	Workspaces con roles, límites por miembro y modelos que un admin puede apagar. La gestión está en beta gratuita	Solo un miembro por workspace puede suscribirse a Go o a Go Plus
Retención de datos	La de tu proveedor	Los proveedores declaran cero retención y no entrenan, con excepciones: modelos gratis, OpenAI y Anthropic (30 días), Muse Spark Contributor y otras listadas en la doc	0 días en la mayoría. 30 días en Grok 4.7, Grok 4.6, GPT 6 Luna y GPT 5.6 Luna. Muse Spark Contributor sí entrena
Bring your own key	Es el modo por defecto	Sí, puedes usar tus claves de OpenAI o Anthropic dentro de Zen. Esos tokens los cobra el proveedor, no Zen	No
Para quién	Quien ya tiene contratos o créditos	Quien necesita modelos que Go no incluye, y control fino del gasto	Quien ejecuta mucho en el catálogo de Go. Go Plus, si ese cupo se queda corto

La lectura rápida de esta tabla: Zen es un catálogo completo con precios de mercado, Go es un subconjunto barato con techo. No compiten, se complementan.

Qué cabe realmente en 10 dólares

Go no te da un fondo común de tokens. Cada modelo tiene un tope mensual en dólares. Sobre ese tope, la ventana de 5 horas es el 20 %, la semana el 50 % y el mes el 100 %.

Eso solo produce 12 USD cada cinco horas, 30 a la semana y 60 al mes cuando el modelo tiene tope de 60 USD. Un modelo de 30 USD permite 6, 15 y 30. Uno de 15 USD permite 3, 7,50 y 15. La frase «pagas 10 y te dan unos 60» describe el primer grupo, no el plan entero.

En la documentación del 29 de septiembre de 2026 los topes de Go se repartían así:

60 USD: GLM-5.3-Flash, GLM-5.2, Kimi K2.7 Code, Kimi K2.6, LongCat-2.0, MiMo-V2.6-Flash, MiMo-V2.5, MiniMax M3, MiniMax M2.7, Muse Spark 1.3 y 1.2 Contributor, Qwen3.7 Plus, DeepSeek V4.1 Flash, Hy3.
30 USD: Qwen3.8 Flash, DeepSeek V4 Flash, Hy4 preview.
15 USD: GLM-5.3, Kimi K3, MiMo-V2.6-Pro, MiMo-V2.5-Pro, Qwen3.8 Max, DeepSeek V4 Pro, DeepSeek V4 Flash Vision Exp, Grok 4.7, Grok 4.6, GPT 6 Luna, GPT 5.6 Luna.
Sin tope de pago, por tiempo limitado: Space Bunny Free y LongCat 2.5 Preview Free.

Go Plus, a 40 USD, no multiplica todo por el mismo factor. GLM-5.3-Flash pasa a 180 USD, Kimi K2.6 a 240 USD, DeepSeek V4.1 Flash a 120 USD, Kimi K3 a 60 USD y Grok 4.7 a 60 USD.

La tabla siguiente copia las peticiones estimadas de Go. OpenCode las calcula con un patrón de uso observado por modelo. No las recalculé.

Modelo	Tope Go	Peticiones / 5 h	Peticiones / semana	Peticiones / mes
Muse Spark 1.3 / 1.2 Contributor	60	45.300	113.300	226.600
MiMo-V2.6-Flash y MiMo-V2.5	60	30.100	75.200	150.400
DeepSeek V4.1 Flash	60	26.000	65.000	130.000
DeepSeek V4 Flash	30	13.000	32.500	65.000
LongCat-2.0	60	11.400	28.600	57.200
GLM-5.3-Flash	60	6.320	15.790	31.580
DeepSeek V4 Flash Vision Exp	15	6.500	16.250	32.500
Qwen3.8 Flash	30	5.400	13.500	27.000
Qwen3.7 Plus	60	4.300	10.800	21.600
Hy3	60	4.300	10.750	21.500
GPT 6 Luna	15	4.230	10.560	21.130
MiniMax M2.7	60	3.400	8.500	17.000
MiMo-V2.6-Pro y MiMo-V2.5-Pro	15	3.250	8.150	16.300
MiniMax M3	60	3.200	8.000	16.000
GPT 5.6 Luna	15	2.050	5.100	10.250
Kimi K2.7 Code	60	1.350	3.380	6.750
Hy4 preview	30	1.350	3.380	6.770
Kimi K2.6	60	1.150	2.880	5.750
DeepSeek V4 Pro	15	1.050	2.600	5.200
GLM-5.2	60	880	2.150	4.300
GLM-5.3	15	220	540	1.080
Grok 4.7 y Grok 4.6	15	169	423	845
Qwen3.8 Max	15	160	400	810
Kimi K3	15	110	250	490

Muse Spark 1.3 Contributor estima 226.600 peticiones al mes. Kimi K3 estima 490. Es el mismo plan de 10 USD. Quien use Go como buffet de «siempre el modelo de más nombre» llena la ventana de 5 horas el primer día. En un modelo de tope 15 USD esa ventana son 3 USD, no 12.

En Go Plus, el mismo GLM-5.3-Flash estima 18.960 peticiones cada 5 horas, 47.370 a la semana y 94.740 al mes. Kimi K3 estima 440, 1.000 y 1.960. Grok 4.7 estima 676, 1.692 y 3.380. El resto de la tabla está en la documentación de Go.

Una tarea agéntica de verdad —añadir autenticación, escribir los tests y actualizar la documentación— no es una petición. Son entre 30 y 150 turnos. Con esa vara, 4.300 peticiones mensuales de GLM-5.2 son entre 30 y 100 tareas medianas al mes. Para una persona, sobra. Para cuatro personas en la misma cuenta, no: solo un miembro por workspace puede suscribirse a Go o a Go Plus.

Si lo que buscas es un desglose enfocado solo en el precio y los límites de Go, sin la parte de Zen ni de estrategia, tengo una reseña dedicada: OpenCode Go: precio, límites de uso y si vale la pena en 2026.

El costo real por turno, para poner las cosas en perspectiva

Para entender por qué la estrategia que propongo funciona, sirve calcular cuánto cuesta un turno agéntico típico en cada modelo. Uso un perfil realista y constante —unos 800 tokens de entrada nueva, 60.000 tokens leídos de caché (el contexto del repo, que es lo que domina el gasto) y 250 tokens de salida— y aplico los precios públicos de Zen:

Modelo	Costo estimado por turno	Turnos por cada $1
GPT 5.6 Luna	$0,00166	~600
DeepSeek V4 Flash	$0,00186	~540
MiniMax M3	$0,0041	~240
Kimi K2.7 Code	$0,0132	~76
Claude Sonnet 5	$0,0161	~62
GLM-5.2	$0,0178	~56
Grok 4.5	$0,0211	~47
Claude Opus 5	$0,0403	~25
GPT 5.6 Sol	$0,0415	~24
Claude Fable 5	$0,0805	~12

Estimación propia del 12 de agosto de 2026, con el perfil descrito y los precios de Zen de ese día. No la volví a calcular el 30 de septiembre de 2026: el catálogo ya incluye modelos más nuevos y los precios se mueven. Sirve para ver el orden de magnitud, no para presupuestar el mes.

Lo que salta a la vista es que la diferencia entre el modelo frontera y el modelo obrero no es de un 30% ni del doble: Claude Fable 5 cuesta más de cuarenta veces lo que cuesta GPT 5.6 Luna o DeepSeek V4 Flash por el mismo turno, y dentro del plan Go esa brecha se ensancha todavía más. Y aquí viene la pregunta incómoda: ¿de verdad esos 150 turnos de "lee el archivo, aplica el diff, corre el test" necesitan el mejor modelo del mundo?

Casi nunca. Lo que sí necesita el mejor modelo del mundo es la decisión de qué construir y cómo. Y esa decisión son cinco o diez turnos, no ciento cincuenta.

Mi recomendación: separa el diseño de la ejecución

Aquí está el núcleo del artículo. Mi flujo, después de bastante prueba y error, es este: defino el spec con Claude o Grok, y ejecuto el spec con OpenCode Go.

Personalmente uso sobre todo Claude —Opus 5 cuando la decisión es arquitectónica y Sonnet 5 para specs más rutinarios— y Grok cuando quiero una segunda opinión con un sesgo distinto o cuando necesito que el modelo sea directo y no complaciente. Codex funciona igual de bien para esta fase si es tu herramienta habitual; el punto no es la marca, es el rol.

La lógica es la misma que aplicamos en cualquier metodología ágil seria: el refinamiento y la ejecución son actividades distintas, con costos y perfiles de riesgo distintos. Nadie pone a su arquitecto a escribir los tests unitarios, y nadie le pide al junior que decida el modelo de datos. Cuando mezclas ambas cosas en una sola conversación con un modelo frontera, pagas precio de arquitecto por trabajo de ejecución durante horas.

Por qué esto funciona técnicamente

Un modelo de ejecución no necesita creatividad; necesita obediencia y competencia. Si el spec es bueno —si dice qué archivos tocar, qué contrato cumplir, qué casos borde cubrir y cómo se verifica el éxito— entonces la tarea deja de ser "diseña esto" y pasa a ser "transcribe esto a código y valídalo". Modelos como GLM-5.2 o Kimi K2.7 Code hacen eso perfectamente bien.

Cuando el spec es malo, en cambio, el modelo de ejecución empieza a improvisar. Y ahí es donde la gente concluye que "los modelos abiertos no sirven". No es que no sirvan: es que les pediste que hicieran dos trabajos y solo les pagaste por uno.

El flujo concreto, paso a paso

1. Conversación de diseño con Claude o Grok. Sin código todavía. Describe el problema, el contexto del negocio y las restricciones. Pídele explícitamente que te haga preguntas antes de proponer. Aquí gastas entre 5 y 15 turnos de un modelo caro, y son los turnos mejor invertidos del proceso.

2. Genera el spec como archivo. Pide la salida en markdown, con esta estructura mínima: objetivo, contexto (qué existe hoy), alcance explícito, fuera de alcance explícito, archivos a tocar, contratos e interfaces, casos borde, criterios de aceptación verificables y plan de verificación. Guárdalo en el repo, por ejemplo en specs/2026-08-12-auth-jwt.md. Que viva en git es parte del punto: es documentación y es trazabilidad.

3. Divide en tareas atómicas. Que cada tarea del spec sea algo que un agente pueda completar y verificar sin ambigüedad. Si una tarea necesita una decisión de producto a mitad de camino, no está lista para ejecutarse; vuelve al paso 1.

4. Ejecuta con OpenCode Go. Abre OpenCode en el repo, señala el spec, y deja que el modelo obrero trabaje. Mi asignación por defecto es GLM-5.2 o Kimi K2.7 Code para la implementación principal, MiniMax M3 o DeepSeek V4 Flash para tareas mecánicas (renombrar, migrar sintaxis, generar tests repetitivos, actualizar imports).

5. Revisión con el modelo caro, solo si hace falta. Si los tests pasan y el diff es legible, no hace falta. Si algo huele raro, pásale el diff a Claude o Grok con la pregunta concreta. Son tres turnos, no treinta.

Ejemplo de spec ejecutable

# Spec: Rate limiting en el endpoint público de búsqueda

## Objetivo
Evitar abuso del endpoint `GET /api/search`, hoy sin protección.

## Contexto
- Express 4 + Redis ya disponible en `src/lib/redis.ts`
- Middleware de auth en `src/middleware/auth.ts` (patrón a imitar)
- No hay tests de middleware todavía

## Alcance
- Middleware `rateLimit` reutilizable, configurable por ruta
- Aplicarlo solo a `GET /api/search`
- Ventana deslizante en Redis, 60 peticiones / 60s por IP
- Responder 429 con header `Retry-After`

## Fuera de alcance
- Rate limiting por usuario autenticado (fase 2)
- Dashboard de métricas
- Cambios en el algoritmo de búsqueda

## Archivos
- Crear: `src/middleware/rateLimit.ts`
- Crear: `src/middleware/__tests__/rateLimit.test.ts`
- Modificar: `src/routes/search.ts` (solo añadir el middleware)

## Contrato
```ts
rateLimit(opts: { windowMs: number; max: number; keyPrefix: string }): RequestHandler
```

## Casos borde
- Redis caído → dejar pasar la petición y loguear warning (fail-open)
- IP ausente en el request → usar `req.socket.remoteAddress`, y si tampoco, no limitar
- Reloj: usar `Date.now()` del servidor, no timestamps del cliente

## Criterios de aceptación
- [ ] 60 peticiones en 60s pasan; la 61 devuelve 429
- [ ] El header `Retry-After` trae segundos hasta el reset
- [ ] Con Redis caído los tests siguen en verde
- [ ] `npm test` y `npm run lint` en verde
- [ ] Ningún archivo fuera de la lista de "Archivos" queda modificado

## Verificación
Ejecutar `npm test -- rateLimit` y `npm run lint`.

Un spec así lo ejecuta GLM-5.2 sin despeinarse, probablemente en 25-40 turnos. A ~0,014 dólares de presupuesto Go por turno, hablamos de medio dólar de tu asignación mensual de 60. Puedes hacer esto más de cien veces al mes.

Elegir la IA según la necesidad y la complejidad

Este es el hábito que más ahorra —dinero y frustración— y el que menos gente cultiva. La pregunta correcta antes de abrir cualquier chat no es "¿cuál es el mejor modelo?", sino "¿qué tipo de trabajo es este?".

Yo lo pienso en cuatro niveles.

Nivel 0 — Mecánico. Renombrar variables, convertir un formato a otro, generar boilerplate, traducir un archivo de configuración, escribir tests repetitivos a partir de un patrón ya establecido. No hay decisiones. Usa un modelo de tope alto y muchas peticiones: MiMo-V2.6-Flash, DeepSeek V4.1 Flash o MiniMax M2.7. Si el resultado está mal, se nota enseguida y reintentarlo gasta poco de ese tope.

Nivel 1 — Implementación guiada. Hay un spec claro y hay que convertirlo en código que compile, pase tests y respete convenciones del proyecto. Requiere competencia real pero no juicio de producto. Aquí viven GLM-5.2, Kimi K2.7 Code, MiniMax M3, Qwen3.7 Plus. Es el 70% del trabajo real de programar y es exactamente el terreno de Go.

Nivel 2 — Diseño acotado. Hay que decidir algo, pero dentro de un marco conocido: cómo modelar esta tabla, qué patrón usar para este caso, cómo estructurar este módulo. Aquí sube el listón: Grok 4.7, Claude Sonnet 5 o un modelo de la misma clase en Zen. Son pocos turnos, así que aunque cuesten más, el impacto en la factura es menor de lo que temes. En Go, Grok 4.7 tiene tope mensual de 15 USD.

Nivel 3 — Decisión con consecuencias. Arquitectura, estrategia de migración, elección de tecnología, análisis de un incidente confuso, cualquier cosa donde equivocarte cuesta semanas. Modelo frontera, sin dudarlo: Claude Opus 5, Claude Fable 5, GPT 5.6 Sol, Gemini 3.1 Pro. Y aquí conviene el lujo de la segunda opinión: hacer la misma pregunta a dos modelos de familias distintas y comparar. Cuando ambos coinciden, tienes una señal razonable; cuando divergen, has encontrado exactamente el punto donde tenías que pensar tú.

La regla que resume todo: el modelo caro decide, el modelo barato ejecuta. Y el corolario, que es igual de importante: si te encuentras usando un modelo frontera para el turno número ochenta de la misma tarea, algo salió mal en el paso de diseño. Vuelve al spec.

Hay un matiz que vale la pena explicitar, porque toca la parte filosófica de todo esto. La tentación de usar siempre el mejor modelo no es económica, es psicológica: se siente más seguro. Pero esa sensación de seguridad tiene un precio real, y no es solo el de la factura. Cuando delegas todo al modelo más capaz, dejas de distinguir entre las decisiones que importan y las que no. Forzarte a clasificar la tarea antes de elegir la herramienta es, en el fondo, un ejercicio de criterio. Y el criterio es lo único que no se puede subcontratar.

Diez tips prácticos para exprimir el plan Go

1. Configura tu modelo por defecto al obrero, no al caro. En tu opencode.json, deja opencode-go/glm-5.2 o opencode-go/kimi-k2.7-code como modelo principal. Cambiar hacia arriba debe ser un acto consciente, no el estado por defecto.

2. Usa el sistema de agentes de OpenCode para asignar modelos por rol. OpenCode permite definir agentes distintos con modelos distintos. Un agente plan con un modelo capaz que solo lee y propone, y un agente build con un modelo barato que ejecuta. Es el flujo de este artículo, automatizado.

3. Escribe un AGENTS.md en la raíz del repo. Convenciones, comandos de test, estructura de carpetas, qué no tocar. Cada cosa que esté ahí es una cosa que el modelo obrero no tiene que adivinar, y adivinar es lo que consume turnos.

4. Aprovecha el caché. El grueso del costo por turno es lectura de caché, no tokens nuevos. Sesiones largas sobre el mismo contexto son mucho más baratas por turno que abrir una sesión nueva por cada tarea pequeña. Agrupa el trabajo relacionado.

5. Vigila la ventana de cinco horas, no el mensual. Esa ventana es el 20 % del tope de ese modelo: 12 USD si el tope es 60, y 3 USD si el tope es 15. Si la sesión va a ser intensa, empieza por un modelo de muchas peticiones y reserva Grok 4.7 o Kimi K3 para cuando se atasque.

6. Activa "Use balance" solo si tienes saldo Zen y sabes por qué. Es la válvula de escape: cuando agotas Go, sigue tirando de tu saldo de pago por uso en vez de bloquearse. Muy útil en un deadline, peligroso si lo dejas activo y te olvidas.

7. Al agotar Go siguen los modelos gratuitos, con letra pequeña distinta. En Go, Space Bunny Free y LongCat 2.5 Preview Free figuran sin tope de pago por tiempo limitado, y la tabla de privacidad de Go los marca a 0 días y sin entrenamiento. En Zen, varios modelos gratis sí pueden usar los datos para mejorar el modelo: Big Pickle, MiMo free, Ling y los endpoints gratuitos de Nemotron, entre otros. Muse Spark Contributor, en Go y en Zen, cambia precio por permiso de entrenamiento. No mandes código confidencial a un modelo que entrena o que retiene.

8. Revisa la tabla de privacidad antes de meter código de cliente. En Go, la mayoría figura a 0 días. Grok 4.7, Grok 4.6, GPT 6 Luna y GPT 5.6 Luna retienen 30 días. Muse Spark 1.3 y 1.2 Contributor sí autorizan el entrenamiento. DeepSeek está a 0 días con un acuerdo que la documentación daba por vigente hasta el 31 de octubre de 2026. Si el código va bajo NDA, esa columna importa más que el benchmark.

9. Ten Zen con saldo aunque uses Go. Diez dólares de Go más veinte de saldo Zen te da lo mejor de ambos: ejecución ilimitada en la práctica, y acceso puntual a modelos frontera cuando la decisión lo justifica. Sigue siendo menos de lo que cuesta una sola suscripción premium.

10. Mide. La consola de OpenCode muestra tu consumo. Míralo una vez por semana durante un mes y vas a descubrir que el 80% de tu gasto viene de dos o tres tipos de tarea. Esas son las que hay que mover a modelos baratos o, mejor, automatizar con un spec reutilizable.

Herramientas prácticas que acompañan bien este flujo

OpenCode (opencode.ai) es la base: TUI, CLI, modo servidor, integración con IDE, soporte de MCP y de Agent Skills. Instalación de una línea, funciona en macOS, Linux y Windows vía WSL.

El comando /connect dentro de la TUI es cómo enchufas Go o Zen: te pide la API key que copias desde la consola en opencode.ai/auth, y con /models ves el catálogo disponible. En tu configuración, los IDs llevan el prefijo del proveedor: opencode-go/kimi-k3 para Go, opencode/gpt-5.6-sol para Zen.

Claude Code, Codex CLI o Grok para la fase de diseño. Cualquiera sirve; lo que importa es que la conversación de spec ocurra en un sitio distinto al de la ejecución, aunque solo sea para no mezclar contextos.

Un directorio specs/ versionado en git. Suena a poco y es la mitad del valor de este método. Los specs se acumulan, se reutilizan, se convierten en plantillas y —esto es lo bueno— se vuelven el mejor onboarding posible para cualquier persona o agente que llegue después.

MCP servers para dar contexto real al agente: acceso a tu base de datos, a tu gestor de tareas, a tu documentación. Un agente con contexto necesita menos turnos, y menos turnos es menos presupuesto consumido.

Los endpoints directos de Go, si quieres construir algo encima. https://opencode.ai/zen/go/v1/chat/completions es compatible con el SDK de OpenAI, y algunos modelos exponen el formato de Anthropic en /v1/messages. Puedes usar tu suscripción de Go desde tus propios scripts, no solo desde la TUI.

Cuándo Go no es la respuesta

Por honestidad, tres escenarios donde yo no lo recomendaría.

Si tu trabajo es mayoritariamente de nivel 3 —consultoría de arquitectura, investigación, análisis— Go te va a servir de poco, porque el valor está en los modelos que no incluye. Paga Zen por uso y ya.

Si sois un equipo, Go no escala: solo un miembro por workspace puede suscribirse. Para equipos, el camino es un workspace de Zen con límites de gasto por miembro y modelos habilitados según el rol.

Y si tu código es confidencial de forma estricta, revisa la tabla de retención modelo por modelo y considera BYOK con un proveedor con el que ya tengas acuerdo contractual. Diez dólares es barato, pero no lo suficiente como para saltarse esa conversación.

Cierre

La conclusión que me llevo después de meses con este flujo no es sobre OpenCode. Es sobre cómo pensamos el gasto en IA en general: seguimos comprando herramientas cuando lo que deberíamos estar diseñando son procesos.

Diez dólares al mes dan para muchísimo si la ejecución llega con instrucciones claras, y dan para bien poco si la usas como sustituto del pensamiento. El plan Go no te hace más productivo por sí solo; te obliga —por diseño, a través de sus límites— a decidir qué merece un modelo caro y qué no. Y esa disciplina, que parece una restricción, termina siendo lo que hace que el trabajo salga mejor.

Define el spec con el mejor modelo que puedas pagar. Ejecútalo con el más barato que aguante. Guarda el spec en git. Repite.

El plan, si lo quieres, está en OpenCode Go. Es la página del producto: el programa de referidos terminó y ese enlace no acredita saldo.

Preguntas frecuentes

¿OpenCode Go reemplaza a Claude Code o a Codex?

No, y no debería. Go es un plan de ejecución con modelos abiertos. Claude Code y Codex siguen siendo mejores para la fase de diseño y para tareas que requieren juicio. El planteamiento de este artículo es usarlos juntos, no elegir.

¿Puedo tener Go y Zen a la vez?

Sí. Go cubre la ejecución dentro de su catálogo. Go Plus, a 40 USD, sube el cupo de esos mismos modelos. Zen cubre lo que Go no incluye. Con "Use balance" activado, al llegar al tope de Go las peticiones siguen contra el saldo Zen.

¿Cuántas tareas reales caben en el plan de 10 dólares?

Depende del modelo. GLM-5.2 estima 4.300 peticiones al mes. Con tareas de 30 a 150 turnos, son entre 30 y 100 tareas medianas. DeepSeek V4 Flash estima 65.000 al mes en Go, y MiMo-V2.6-Flash estima 150.400. Kimi K3 estima 490. El plan no se comporta igual en todos.

¿Por qué Kimi K3 solo estima 490 peticiones al mes en Go?

Porque el tope es por modelo. Kimi K3 tiene tope mensual de 15 USD en Go, no de 60. Grok 4.7 y Grok 4.6 también están en 15 USD y estiman 845 peticiones al mes. No es un multiplicador único de 6x aplicado a todo el catálogo. En Go Plus, el tope de Kimi K3 pasa a 60 USD y la estimación sube a 1.960 peticiones al mes.

¿Qué pasa si agoto el límite?

Puedes seguir usando los modelos gratuitos del catálogo, o activar "Use balance" para tirar de tu saldo de Zen. También puedes esperar a que se reinicie la ventana de cinco horas.

¿Sirve OpenCode Go para equipos?

No como cuota compartida: solo un miembro por workspace puede suscribirse a Go o a Go Plus. Para equipos, la vía publicada es un workspace de Zen con roles, límites de gasto por miembro y control de qué modelos se habilitan.

¿Se usan mis datos para entrenar?

En la tabla de Go del 29 de septiembre de 2026, la mayoría dice que no, con retención de 0 días. Grok 4.7, Grok 4.6, GPT 6 Luna y GPT 5.6 Luna retienen 30 días y figuran como no usados para entrenar. Muse Spark Contributor sí autoriza el entrenamiento. En Zen, varios modelos gratis pueden usar los datos para mejorar el modelo, y OpenAI y Anthropic retienen 30 días. La lista de excepciones está en la documentación de cada producto.

Sigue leyendo

Si quieres solo el precio, los límites y mi experiencia usando OpenCode Go en solitario, sin la parte de Zen ni de estrategia de specs: OpenCode Go: precio, límites de uso y si vale la pena en 2026.

Si te interesa el resto del panorama de proveedores de IA para programar, más allá de OpenCode: Por qué en 2026 ya no deberías depender de un solo proveedor de IA para programar.

Fuentes

Catálogo, topes y peticiones estimadas de Go verificados el 29 de septiembre de 2026. Zen, recarga automática y excepciones de privacidad verificados el 30 de septiembre de 2026. La tabla de costo por turno es una estimación del 12 de agosto de 2026 y no se recalculó. El catálogo cambia; consulta la documentación antes de pagar.