Dos veces 10 $: la API de DeepSeek o el cupo de OpenCode Go

Hay una pregunta que se repite en foros, discords y conversaciones de equipo: si DeepSeek V4.1 Flash cuesta lo mismo por token en la API y en OpenCode Go, ¿por qué pagar 10 $ al mes en lugar de 10 $ de saldo? La respuesta corta es que no compras lo mismo. La API te vende tokens a precio de lista, sin caducidad mensual y sin cupo mensual de peticiones. Go te vende un cupo mensual de 80 $ por 10 $, con ventanas de 5 horas y semanales, y con un límite que se renueva cada mes.

La respuesta larga cabe en una frase: Go no es una tarifa más barata, es un descuento por volumen empaquetado en una suscripción. Ese descuento nominal es de 8 veces. Lo que llega a tu factura depende de tres cosas que no aparecen en la portada: la caché, la velocidad y el volumen real de uso. Con los datos de octubre de 2026, el multiplicador real que se deduce de las mediciones de la comunidad se sitúa entre 2,7 y 3,2 veces, no en 8. Y por debajo de cierto volumen, la API directa es sencillamente más barata.

Este artículo compara las dos opciones con precios oficiales, matemática explícita y mediciones de terceros. Al final hay una guía de pago, otra de instalación y una tabla para decidir según tu perfil. Los precios son del 21 de octubre de 2026; las fuentes están al final.

Qué compra cada opción

Antes de comparar precios conviene separar dos productos que se parecen solo en la cifra de entrada.

Desliza para ver todas las columnas →

La diferencia importante no es el precio por token: es qué pasa con lo que no usas. En la API, el saldo sigue ahí el mes siguiente. En Go no hay traspaso de cupo entre meses anunciado: el límite es mensual. Esa es la razón por la que Go solo tiene sentido si vas a consumir una parte relevante de los 80 $ cada mes.

El precio oficial de DeepSeek

DeepSeek V4.1 Flash se llama deepseek-flash en la API y comparte precios con la versión anterior. La tabla oficial distingue hora valle y hora punta, y aplica la tarifa valle a todo lo que queda fuera de dos franjas UTC de lunes a viernes.

Desliza para ver todas las columnas →

Precios por millón de tokens, en dólares y sin impuestos. Fuente: DeepSeek, Models & Pricing.

Las horas punta son 01:00–04:00 y 06:00–10:00 UTC, de lunes a viernes, excluyendo festivos chinos. Todo lo demás es valle, incluidos los fines de semana. En España, en horario de verano, eso son las 03:00–06:00 y las 08:00–12:00; desde el 25 de octubre pasa a 02:00–05:00 y 07:00–11:00. En México, Argentina o Colombia, la jornada laboral cae casi entera en valle.

La letra pequeña que más importa: la caché cuesta un 98 % menos que la entrada nueva. Un token que se repite se cobra a 0,003 $ en valle; uno nuevo, a 0,15 $. Esa diferencia es la que decide si el cupo de Go se agota rápido o despacio.

Cómo funciona el cupo de OpenCode Go

OpenCode Go cuesta 10 $ al mes y da acceso a 29 modelos. No es un precio por token distinto: es un límite mensual en dólares que se consume a los precios oficiales de cada modelo. En DeepSeek V4.1 Flash, ese límite es de 80 $; en V4 Pro, de 15 $. Go Plus, de 40 $, sube el cupo de Flash a 160 $.

Desliza para ver todas las columnas →

El cupo se reparte en tres ventanas: 20 % cada 5 horas, 50 % cada semana y 100 % al mes. En Flash, eso son 16 $ por ventana de 5 horas y 40 $ por semana. La tabla de OpenCode traduce esos importes a peticiones estimadas usando un perfil típico: 410 tokens de entrada nueva, 71.300 de lectura de caché y 310 de salida por petición.

Desliza para ver todas las columnas →

Las cifras de valle son las que publica OpenCode; las de punta son la mitad, porque los precios se duplican. Fuente: OpenCode Go, Usage limits.

Dos matices que la tabla no dice:

• El cupo es por modelo, no una bolsa común. Gastar 80 $ en Flash no consume el cupo de Kimi o de GLM. Cada modelo tiene su propio límite.
• Go es para un workspace de un solo miembro. La documentación lo restringe al workspace personal; no se puede invitar a otras personas a un workspace con suscripción Go.

Y un tercero que sí importa para la comparación: OpenCode Console, el pago por uso, no aplica la tarifa valle de DeepSeek. Lista Flash a 0,30 $ de entrada, 1,20 $ de salida y 0,006 $ de caché, es decir, precio de punta. Es un producto distinto de Go y de la API directa; no los confundas al comparar.

La aritmética de los 10 $

Con el perfil de OpenCode, una petición en hora valle cuesta 0,0004614 $: 0,0000615 $ de entrada nueva, 0,0002139 $ de caché y 0,000186 $ de salida. En punta, el doble: 0,0009228 $.

Ese perfil permite comparar sin hablar de “millones de tokens”, una unidad que nadie factura. Con 10 $ se compran 21.670 peticiones en valle o 10.836 en punta. Con 80 $, 173.330 en valle o 86.665 en punta. Y Go, por 10 $, ofrece justamente esos 80 $ de cupo.

Desliza para ver todas las columnas →

La tabla contiene la conclusión menos evidente del artículo: por debajo de unas 21.670 peticiones al mes en valle —o 10.836 en punta—, la API directa es más barata que Go, aunque el cupo nominal sea de 80 $. La suscripción no es un descuento universal: es un descuento para quien consume mucho. Un desarrollador que gasta 4 $ al mes en la API no ahorra 70 $ con Go; paga 6 $ de más.

Si el consumo supera el cupo, Go no bloquea necesariamente: permite activar Extra usage y seguir usando el saldo de créditos del Console, o caer a los modelos gratuitos. Pero a partir de ahí ya no estás usando el descuento, estás pagando por uso.

El multiplicador real: 8× nominal, 2,7–3,2× real

La promesa de Go se suele resumir como “pagas 10 $ y recibes 80 $”: un multiplicador de 8×. Es correcto en términos nominales: si consumes exactamente 80 $ de cupo, el descuento es del 87,5 %. El problema es que el cupo se consume con tokens, no con tareas. Si el mismo trabajo genera más tokens en Go que en la API —porque la caché acierta menos—, el multiplicador efectivo baja.

La medición comunitaria más citada es de finales de septiembre de 2026. Un usuario comparó el mismo prompt y el mismo harness (Pi) contra Go High, Go Max, API directa High y API directa Max, midiendo contexto, lectura de caché, acierto y coste:

Desliza para ver todas las columnas →

Datos de un usuario en r/opencode, 26 de septiembre de 2026. Es una muestra pequeña, no un benchmark controlado. La medición se hizo cuando el cupo de Flash era de 60 $; lo que compara la tabla es el coste a precios de API por sesión, no el cupo. Con los 80 $ actuales, el 8× nominal se traduce en ese rango de 2,7–3,2×.

La diferencia de coste API por sesión es de 2,5 a 3 veces, no de 8. Eso deja el multiplicador efectivo entre 2,7 y 3,2× (8 dividido entre 3 y 2,5): sigues ahorrando, pero no tanto como sugiere la portada. El multiplicador solo se realiza si agotas el cupo; si el consumo por tarea se multiplica por 8, Go y la API empatan a ese nivel de uso, y por encima de 8 la API directa gana.

Hay un detalle que la tabla de coste esconde: la caché no solo abarata; también cambia la forma del gasto. En la API, un fallo de caché se paga a 0,15 $ por millón de entrada nueva. En Go, se paga con el mismo cupo de 80 $, así que un mal día de caché no te cuesta más dinero, pero sí te acerca al límite y puede dejarte sin servicio antes de fin de mes. Es un riesgo distinto, no un coste distinto.

La caché decide más que el descuento

DeepSeek activa la caché de contexto por defecto. Cada petición crea unidades de prefijo al final de la entrada y de la salida; una petición posterior solo acierta si coincide por completo con una de esas unidades. El sistema también detecta prefijos comunes y los persiste como unidades independientes, y corta unidades cada cierto número de tokens en entradas o salidas largas. La documentación insiste en dos ideas: el acierto exige coincidencia completa con una unidad de prefijo, y el sistema es best effort, sin garantía del 100 %. La caché se borra sola en cuestión de horas o días.

Eso significa que el harness, el orden de los mensajes y la estabilidad del prefijo importan tanto como el modelo. Un agente que reordena archivos, inserta marcas de tiempo o cambia el sistema de instrucciones entre turnos rompe el prefijo y paga entrada nueva. Un agente que mantiene una sesión estable y reutiliza el mismo contexto acierta más.

La API expone el resultado en usage:

{
  "prompt_cache_hit_tokens": 71280,
  "prompt_cache_miss_tokens": 430,
  "completion_tokens": 310
}

Con esos tres números puedes calcular tu coste real y tu tasa de acierto. La fórmula, en valle:

coste = (miss × 0,15 + hit × 0,003 + salida × 0,60) / 1.000.000
acierto = hit / (hit + miss)

En la medición de r/opencode, la API directa tuvo cero fallos de caché y un 92,6 % de acierto; Go se quedó en 74,8–81,1 %. Pero no es una ley: hay usuarios que reportan 95–99 % con OpenCode, Pi u OpenChamber, y un usuario de Hacker News reporta 98,6 % con OpenCode sobre deepseek-v4-flash, no con la API directa. La conclusión razonable no es “Go cachea peor”, sino “Go cachea distinto según el cliente, la región y la sesión; mide el tuyo”.

Velocidad: el otro precio

El coste por token no es la única variable. En un agente interactivo, la velocidad cambia cuánto trabajo haces y cuánto esperas. Aquí los reportes también están divididos.

Un usuario de r/opencode midió 70–80 tokens/s con Go frente a 270–280 tokens/s con la API directa, con la misma tarea y el mismo harness, y describió cortes de servidor que no veía en la API. En el mismo hilo, otras respuestas reportan hasta 367 tokens/s con Go, así que no es un límite universal: depende de la ruta, la hora y el proveedor que haya detrás.

La medición más sistemática está en el issue #39845 de OpenCode. Un usuario en China continental, con conexión directa y sin proxy, midió el mismo modelo:

Desliza para ver todas las columnas →

Diez muestras por ruta, deepseek-v4.1-flash frente a deepseek-flash, el mismo modelo. Todas las peticiones de Go pasaron por el nodo de Cloudflare en Los Ángeles (LAX). El propio autor señala que el problema es de la pasarela, no del modelo, porque Kimi K3 mostraba la misma lentitud.

Ese dato no se puede extrapolar a España o Latinoamérica: la ruta desde China a LAX es un caso extremo. Pero sí enseña la pregunta correcta. No preguntes “cuánto cuesta Go”, pregunta “cuánto cuesta Go en mi red, a mi hora y con mi harness”. Si trabajas de forma interactiva con el agente, 300 ms de latencia extra por turno se notan; si lanzas tareas largas y las revisas después, casi no.

Límites, caducidad y permanencia

Aquí está la diferencia económica más limpia entre los dos productos.

La API no tiene cupo mensual. Tiene un límite de concurrencia: 2.500 conexiones simultáneas para deepseek-flash y 500 para deepseek-v4-pro, por cuenta. Si lo superas, recibes un HTTP 429. No hay un “se acabó el mes”: mientras haya saldo, puedes seguir.

Go tiene tres ventanas y un techo. El 20 % cada 5 horas evita que un script consuma el mes en una tarde; el 50 % semanal reparte el uso; el 100 % mensual es el techo. Al llegar, puedes seguir con modelos gratuitos o activar Extra usage. Lo que no se usa en una ventana no se recupera después, y no hay traspaso de cupo entre meses anunciado.

El saldo de la API no es un cupo mensual. DeepSeek separa el saldo concedido (granted_balance, que puede caducar) del saldo recargado (topped_up_balance, sin caducidad publicada). El segundo se gasta cuando se usa, no cuando pasa el mes. Es la diferencia entre “lo que no usas sigue ahí” y “lo que no usas se pierde”.

Esa diferencia tiene un valor. Si tu uso es irregular —un mes intenso, dos semanas de vacaciones—, la API se adapta mejor. Si tu uso es constante y alto, Go convierte esa previsibilidad en un descuento.

El harness importa: OpenCode y DeepSeek Harness

OpenCode Go no está atado a OpenCode. La documentación lo define como un proveedor para OpenCode y otros agentes de programación, y mantiene una lista de clientes validados: Claude Code, Codex, Hermes, Pi y Raycast, además de ZCode, jcode y Kilo Code CLI. La condición es enviar tráfico típico de agente y una sesión estable en x-opencode-session o en la cabecera nativa que OpenCode reconozca.

Eso no significa que todos cacheen igual. OpenCode es el cliente de referencia y el que mejor encaja con el enrutado y la caché de Go; los demás están validados, pero la documentación avisa de que no garantiza que sigan funcionando. DeepSeek Harness sigue en la lista de clientes problemáticos: la sesión llega en algunas rutas de modelo y falta en otras.

En la práctica:

• OpenCode es la apuesta segura para Go: el enrutado y la caché están pensados para él.
• Claude Code, Codex, Hermes, Pi y Raycast funcionan con Go. Claude Code habla Anthropic Messages y Codex OpenAI Responses, así que cada uno alcanza una parte del catálogo; Hermes, Pi y Raycast llegan a todos los modelos.
• DeepSeek Harness funciona con la API directa; con Go, la cabecera de sesión incompleta puede costar caché.

Desliza para ver todas las columnas →

Codex y Hermes necesitan versiones recientes; en Codex, algunas versiones o proxys omiten la cabecera de sesión, y conviene conservarla al reenviar peticiones.

Desliza para ver todas las columnas →

La recomendación práctica ya no es “si pagas Go, usa OpenCode” sin matices. OpenCode sigue siendo el cliente de referencia y el que mejor garantiza el enrutado y la caché; pero Go funciona en Claude Code, Codex, Hermes, Pi y Raycast. Si tu cliente habitual está en esa lista, pruébalo con Go antes de cambiar de harness. Si usas DeepSeek Harness, la API directa evita la dependencia de una cabecera que el harness todavía no envía bien en todas las rutas.

Dentro de OpenCode, la diferencia entre TUI y escritorio es de interfaz, no de motor: ambos usan el mismo agente y la misma sesión. El escritorio añade panel de cambios, historial y una experiencia más cómoda; no cambia el precio ni la caché.

La app de escritorio de DeepSeek Harness

DeepSeek Harness ya no es solo una web local. La versión de escritorio es reciente: el release 0.2.1-rc.2, del 17 de octubre de 2026, incluye correcciones específicas para Windows y macOS. La descarga oficial está en deepseek.com/download, con instaladores para macOS Apple silicon (macOS 13 o posterior) y Windows x64 (Windows 10 o posterior). La app corre en segundo plano, lee y escribe archivos locales y está pensada para tareas largas; la configuración de modelos se hace en Settings → Models, como en la web.

La web local (npx @deepseek-ai/dsh web) y el CLI no desaparecen: son la vía para Linux, servidores y flujos headless. La app de escritorio es otro cliente del mismo harness, no un producto distinto.

Los modelos gratuitos son otra cosa. No son una prueba de Go ni un plan “Go Free”: son modelos promocionales de OpenCode con una cuota de 200 peticiones al día, disponibles por tiempo limitado, e incluyen DeepSeek V4.1 Flash Free. La documentación los presenta como gratis en OpenCode y no anuncia esa cuota para otros harnesses. Si usas Go en Claude Code o Codex, lo que está documentado es el cupo de Go; la cuota gratuita de 200/día está documentada para OpenCode. Si tu uso es ligero, esa cuota puede bastar sin pagar nada; si agotas Go, puedes seguir con los modelos gratuitos desde OpenCode.

Cómo pagar cada opción

API directa de DeepSeek

1. Crea una cuenta en platform.deepseek.com.
2. Entra en Top up y recarga saldo. Los métodos disponibles dependen de la región y la plataforma los muestra antes de confirmar la recarga.
3. Crea una API key en API Keys. Usa una clave por proyecto y no la compartas.
4. Configura el cliente con https://api.deepseek.com (formato OpenAI) o https://api.deepseek.com/anthropic (formato Anthropic).

No hay suscripción ni renovación. El saldo es prepago y se descuenta con cada petición. Los precios son en dólares; pueden aplicarse impuestos según el país. Si recargas 10 $, esos 10 $ rinden según la tabla de arriba, no según el cupo de Go.

OpenCode Go

1. Inicia sesión en OpenCode Console y abre Go.
2. Suscribe el plan Go (10 $) o Go Plus (40 $). El pago se gestiona con Stripe.
3. Añade un método de pago: tarjeta, Link, Alipay, UPI o WeChat Pay.
4. Copia la API key del workspace.
5. En OpenCode, ejecuta /connect, elige OpenCode Go y pega la clave.

La suscripción se renueva automáticamente y se puede cancelar en cualquier momento. Hay reembolso si el cargo tiene menos de 14 días y no has usado el cupo de ese periodo. Si compras créditos adicionales, se aplica un 4,6 % + 0,31 $ por operación: 50 $ cuestan 52,61 $. Para el uso extra, activa Extra usage en la tarjeta de créditos del Overview.

Un aviso: Go y Go Plus son para workspaces de un solo miembro. Si necesitas compartir el acceso con un equipo, la API directa o un workspace de Console con créditos encaja mejor.

Cómo instalar cada harness

OpenCode

En Linux, macOS o WSL:

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

Con npm:

npm install -g @opencode/cli

En Windows, OpenCode 2 ofrece binarios para la CLI y un instalador de escritorio desde opencode.ai/download; los gestores de paquetes de Windows no están soportados para la CLI. Si prefieres un entorno Linux, usa WSL2.

Después:

/connect
/models

Si usas Go, elige el proveedor OpenCode Go y el modelo opencode-go/deepseek-v4.1-flash. Si usas la API directa, elige DeepSeek y deepseek/deepseek-flash. En ambos casos, /init crea un AGENTS.md con el contexto del repositorio, que ayuda a mantener el prefijo estable y mejora la caché.

DeepSeek Harness

Tiene dos formas de uso.

App de escritorio. Descarga el instalador desde deepseek.com/download: macOS Apple silicon (macOS 13 o posterior) o Windows x64 (Windows 10 o posterior). Es la vía más cómoda para trabajo local; la app corre en segundo plano y lee y escribe archivos del proyecto.

Web local o CLI. Necesitas Node.js. Desde la carpeta del proyecto:

npx @deepseek-ai/dsh web

El comando arranca la interfaz web en http://127.0.0.1:3080 y la abre en el navegador. En una sesión SSH solo imprime la URL; añade --no-open si no quieres que intente abrir nada. En Linux, la web local y el CLI son la vía disponible; la página de descargas solo ofrece macOS y Windows.

Después, en la app o en la web:

1. Abre Settings → Models.
2. Pega tu API key de DeepSeek y guarda.
3. Elige un workspace con Choose workspace.
4. Crea una sesión y prueba una tarea pequeña.

DeepSeek Harness está en developer preview y avisa de que habrá cambios incompatibles. Para Go, recuerda el problema de la cabecera de sesión; para la API directa, es una integración oficial. La versión 0.2.1-rc.2 incorpora soporte para DeepSeek V4.1 Flash y para las APIs de búsqueda y fetch.

Qué dice la comunidad

La conversación pública sobre Go y DeepSeek tiene tres capas.

La primera es la caché. Los hilos de r/opencode se llenan de capturas con aciertos del 70–81 % en Go y del 92,6 % en la API directa en la prueba de septiembre; otros usuarios ven 95–99 % con configuraciones distintas. Algunos describen “fallos completos de caché cada pocos mensajes”; otros responden que con su configuración no los ven. La conclusión práctica es que la caché es sensible al cliente y a la sesión, y que la única medición que cuenta es la tuya.

La segunda es la velocidad. El hilo de 70–80 tokens/s frente a 270–280 tiene respuestas para todos los gustos: desde “es normal, Go comparte hardware” hasta “yo tengo 367 tokens/s”. La medición de latencia del issue #39845 es más sólida, pero está hecha desde China y mide una ruta concreta. Sirve para saber qué mirar, no para concluir que Go es lento para todos.

La tercera es el precio y la confianza. En agosto de 2026, una subida de precios de DeepSeek coincidió con un recorte del cupo de Go y provocó una reacción fuerte: el hilo “Bye bye OpenCode Go” acumuló cientos de votos, y otro titulado “DeepSeek V4 Flash x16 pricier” hizo lo propio. El cupo de Flash se revisó después hasta los 80 $ actuales. La lección no es que Go sea malo, sino que sus límites son una decisión comercial que puede cambiar, y que la API directa tiene la misma exposición: los precios de DeepSeek también se movieron.

Hay un contrapunto útil: el análisis de haimaker, publicado el 27 de agosto de 2026 y anterior al cupo de 80 $, concluye que el coste fijo protege de los picos y que la API directa recupera ventaja cuando el volumen sostenido supera el cupo o se puede mover a valle. Su análisis pone el acento en algo que este artículo no resuelve: qué checkpoint sirve cada proveedor.

Cómo medir tu propio coste

No necesitas un benchmark. Necesitas una semana de datos.

1. Elige diez tareas representativas de tu trabajo real, con su criterio de aceptación.
2. Ejecútalas con el mismo harness en Go y en la API directa, en la misma franja horaria.
3. Apunta tokens: prompt_cache_hit_tokens, prompt_cache_miss_tokens, completion_tokens, reintentos y tiempo hasta el primer token.
4. Calcula el coste por tarea aceptada, no por millón de tokens: (miss × precio_miss + hit × precio_hit + salida × precio_salida) / 1.000.000.
5. Compara el multiplicador: coste API / coste Go. Si es menor que 8, Go sigue ganando; si es mayor, no.
6. Repite el mes siguiente. Los precios, los límites y las rutas cambian.

Para el saldo de la API, GET https://api.deepseek.com/user/balance devuelve granted_balance y topped_up_balance. Para Go, el Console muestra el consumo por modelo y por ventana. Si no ves la caché en el harness, no puedes optimizar: cambia de cliente o de configuración antes de cambiar de plan.

Qué elegir según tu perfil

Perfil	Opción razonable	Por qué
Uso ligero, menos de 10 $ al mes	API directa	Go cuesta 10 $ aunque consumas 1 $
Uso medio, 10.000–20.000 peticiones	API directa en valle	Sigue siendo más barata que la suscripción
Uso intensivo, 25.000–173.000 peticiones	Go	El cupo de 80 $ rinde más que 10 $ de saldo
Trabajo interactivo y sensible a latencia	API directa, o probar Go primero	La ruta y el nodo cambian la experiencia
Tareas batch o nocturnas	API directa en valle	50 % de descuento y sin ventanas
Quieres probar muchos modelos	Go	29 modelos y Extra usage
Necesitas control de la ruta	API directa o proveedor propio	Go añade una pasarela intermedia
Equipo de varias personas	API directa o Console con créditos	Go es para workspaces de un solo miembro

La regla de oro: Go es un descuento por volumen, no un plan más barato para todo el mundo. Si no vas a agotar una parte sustancial del cupo, la API directa te da lo mismo con menos ataduras.

Conclusión

Los dos productos cuestan 10 $, pero no compiten en el mismo eje. La API directa vende flexibilidad: pagas por lo que usas, eliges la hora, no hay cupo mensual y el saldo sigue ahí. OpenCode Go vende volumen con descuento: 80 $ de cupo por 10 $, con ventanas, un techo mensual y un cliente que, si está bien configurado, cachea mejor.

El multiplicador de 8× es real solo en el mejor caso, cuando agotas el cupo. Con la caché medida por la comunidad, el ahorro efectivo está entre 2,7 y 3,2×, y por debajo de unas 21.670 peticiones al mes en valle —10.836 en punta— la API directa es más barata. La velocidad añade otra variable: hay quien ve 70 tokens/s en Go y quien ve 367; la latencia de la pasarela puede triplicar la de la API directa según la región.

La decisión, por tanto, no es “cuál es más barato”, sino “cuánto voy a consumir, desde dónde y con qué cliente”. Si la respuesta es “poco, desde Europa o América”, la API directa suele ganar. Si es “mucho, todos los días, con un cliente validado y sin salir del cupo”, Go sigue siendo una de las mejores compras de 10 $ del mercado.

Fuentes y precios consultados

Precios y límites consultados el 21 de octubre de 2026. No incluyen impuestos. Verifica siempre en la página oficial antes de presupuestar.

• DeepSeek: Models & Pricing
• DeepSeek: Context Caching
• DeepSeek: Rate Limit & Isolation
• DeepSeek: Get User Balance
• DeepSeek: integración con OpenCode
• OpenCode Go: documentación y límites
• OpenCode Go: página del plan
• OpenCode Console: precios de pago por uso
• OpenCode Console: facturación y métodos de pago
• OpenCode: instalación de la versión 2
• OpenCode: página de descargas
• DeepSeek Harness: guía de inicio
• DeepSeek Harness: descarga de escritorio
• DeepSeek Harness: repositorio
• DeepSeek Harness: notas del release 0.2.1-rc.2
• OpenCode: harness compatibles con Go
• OpenCode Go: preguntas frecuentes, cuota gratuita y reembolsos
• r/opencode: medición de caché y coste por sesión
• r/opencode: fallos de caché con DeepSeek V4.1 Flash
• r/opencode: velocidad de Go frente a la API directa
• GitHub: latencia de OpenCode Go medida
• Hacker News: 98,6 % de acierto de caché con OpenCode
• r/opencodeCLI: “Bye bye OpenCode Go”
• r/opencode: “DeepSeek V4 Flash x16 pricier”
• haimaker: dónde comprar DeepSeek V4