OpenCode Zen vs Go: qual escolher (e se pode usar os dois)

Zen é saldo pré-pago. Go custa 10 USD por mês desde a primeira cobrança e Go Plus 40 USD, com mais cota por modelo. Quando usar um, o outro ou os dois.

Índice

Primeiro, vamos esclarecer os três nomes que todo mundo confunde
Tabela comparativa: BYOK, Zen e Go
O que realmente cabe em 10 dólares
O custo real por turno, para colocar as coisas em perspectiva
Minha recomendação: separe o design da execução
Escolher a IA conforme a necessidade e a complexidade
Dez dicas práticas para espremer o plano Go
Ferramentas práticas que acompanham bem esse fluxo
Quando o Go não é a resposta
Fechamento
Perguntas frequentes
Continue lendo
Fontes

Existe um padrão que vejo se repetir entre empreendedores técnicos e equipes pequenas: assinatura do Claude, assinatura do ChatGPT, assinatura do Cursor, créditos avulsos em algum gateway, e uma sensação difusa de estar queimando entre 60 e 200 dólares por mês sem saber exatamente em quê. Quando a pessoa para para olhar a fatura, quase sempre descobre a mesma coisa: o gasto não está em pensar, está em executar. Os tokens não vão embora na conversa onde você decide a arquitetura; vão embora nas trezentas iterações em que um agente lê arquivos, roda testes, corrige um import e volta a ler.

Essa distinção — pensar versus executar — é exatamente a brecha que o OpenCode Go ataca, um plano de 10 dólares por mês que há alguns meses vem mudando a equação de custos para quem sabe usá-lo. Este artigo é a minha análise do que realmente cabe nesses 10 dólares, no que ele se diferencia do OpenCode Zen, e por que a minha recomendação final não é «migre para o Go», e sim algo bem mais matizado: defina os specs com o modelo mais caro que você conseguir pagar, e execute-os com o mais barato que aguente a tarefa.

Primeiro, vamos esclarecer os três nomes que todo mundo confunde

OpenCode é um agente de código de terminal, open source, mantido pela Anomaly. É a ferramenta: uma TUI onde você escreve, um agente que lê o seu repositório, edita arquivos, roda comandos e mostra os diffs. É grátis e sempre foi.

OpenCode Zen é outra coisa. É um gateway de modelos — um intermediário — que o time da OpenCode construiu depois de esbarrar num problema real: existem dezenas de modelos que dizem servir para programar, mas muito poucos funcionam bem como agentes, e os que funcionam bem entregam resultados bem diferentes conforme qual provedor os serve. Um mesmo modelo pode render excelente num provedor e medíocre noutro, com o mesmo rótulo. O Zen é a resposta a isso: testaram modelos, conversaram com os times que os treinam, negociaram com provedores para que os servissem corretamente, fizeram benchmarks da combinação modelo/provedor e publicaram uma lista curada. Paga-se por uso, com preços por milhão de tokens e sem markup declarado além das taxas de processamento de pagamento.

OpenCode Go é a assinatura. Custa 10 USD por mês desde a primeira cobrança e dá acesso a um catálogo de modelos abertos, com um teto em dólares por modelo, não um bolso único do plano. Go Plus custa 40 USD por mês, usa os mesmos modelos e sobe esse teto. O salto não é um múltiplo único: na documentação de 29 de setembro de 2026, o GLM-5.3-Flash passa de 60 para 180 USD e o Kimi K2.6 de 60 para 240 USD. Não é um plano ilimitado. O primeiro mês a 5 USD já não existe, e o programa de indicação acabou.

Atualizado em 30 de setembro de 2026.

Os três nomes continuam independentes. O Go Plus é um segundo preço do mesmo catálogo do Go, não um quarto produto. Você pode usar o OpenCode com as suas próprias chaves da OpenAI ou da Anthropic e não pagar um centavo nem ao Zen nem ao Go. Você pode usar o Zen a partir de outro agente que não seja o OpenCode. E você pode ter Go e Zen ao mesmo tempo, que é justamente o que eu recomendo mais adiante.

Tabela comparativa: BYOK, Zen e Go

	OpenCode BYOK	OpenCode Zen	OpenCode Go
Modelo de cobrança	Grátis (você paga o provedor)	Pago por uso, pré-pago com saldo	Assinatura fixa
Preço	$0 + o que você gastar na sua API	Conforme os tokens consumidos	$10/mês desde a primeira cobrança. Go Plus: $40/mês
Catálogo	Qualquer provedor que você suportar	A lista pública da documentação: Claude, GPT, Gemini, Grok, Qwen, DeepSeek, GLM, Kimi, MiniMax e modelos grátis por tempo limitado	O catálogo do Go. Inclui Grok 4.7 e 4.6, GLM-5.3 e GLM-5.3-Flash, GPT 6 Luna e GPT 5.6 Luna, Kimi, Qwen, DeepSeek, MiniMax, MiMo e outros. O Go Plus usa a mesma lista
Modelos de fronteira	Sim, se você pagar a API	Sim. A lista do Zen inclui Claude, GPT, Gemini e Grok, além de modelos abertos	Não inclui Claude, GPT Sol nem Gemini Pro. Inclui Grok 4.7, Grok 4.6, GPT 6 Luna e GPT 5.6 Luna, com teto de 15 USD por mês no Go
Limites	Os do seu provedor	O seu saldo, e um limite mensal de workspace ou de membro se você configurar	Por modelo: 5 horas = 20% do teto dele, semana = 50%, mês = 100%. No Go esse teto é 15, 30 ou 60 USD conforme o modelo
Recarga automática	N/A	Se o saldo cai abaixo de $5, recarrega $20. Você pode mudar o valor ou desligar. Um limite mensal não freia essa recarga	N/A, é tarifa fixa
Ao esgotar o limite	N/A	Recarrega ou para	Você segue com os modelos gratuitos, ou cai no seu saldo Zen se ativar "Use balance"
Equipes	Manual	Workspaces com papéis, limites por membro e modelos que um admin pode desligar. A gestão está em beta grátis	Só um membro por workspace pode assinar o Go ou o Go Plus
Retenção de dados	A do seu provedor	Os provedores declaram retenção zero e não treinam, com exceções: modelos grátis, OpenAI e Anthropic (30 dias), Muse Spark Contributor e outras listadas na doc	0 dias na maioria. 30 dias em Grok 4.7, Grok 4.6, GPT 6 Luna e GPT 5.6 Luna. Muse Spark Contributor treina
Bring your own key	É o modo padrão	Sim, você pode usar as suas chaves da OpenAI ou da Anthropic dentro do Zen. Esses tokens são cobrados pelo provedor, não pelo Zen	Não
Para quem	Quem já tem contratos ou créditos	Quem precisa de modelos que o Go não inclui, e controle fino do gasto	Quem executa muito no catálogo do Go. Go Plus, se essa cota ficar curta

A leitura rápida desta tabela: o Zen é um catálogo completo com preços de mercado, o Go é um subconjunto barato com teto. Eles não competem, se complementam.

O que realmente cabe em 10 dólares

O Go não te dá um fundo comum de tokens. Cada modelo tem um teto mensal em dólares. Sobre esse teto, a janela de 5 horas é 20%, a semana é 50% e o mês é 100%.

Isso só produz 12 USD a cada cinco horas, 30 na semana e 60 no mês quando o modelo tem teto de 60 USD. Um modelo de 30 USD permite 6, 15 e 30. Um de 15 USD permite 3, 7,50 e 15. A frase «você paga 10 e te dão uns 60» descreve o primeiro grupo, não o plano inteiro.

Na documentação de 29 de setembro de 2026 os tetos do Go se repartiam assim:

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 e 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.
Sem teto pago, por tempo limitado: Space Bunny Free e LongCat 2.5 Preview Free.

O Go Plus, a 40 USD, não multiplica tudo pelo mesmo fator. O GLM-5.3-Flash passa a 180 USD, o Kimi K2.6 a 240 USD, o DeepSeek V4.1 Flash a 120 USD, o Kimi K3 a 60 USD e o Grok 4.7 a 60 USD.

A tabela seguinte copia os pedidos estimados do Go. A OpenCode calcula com um padrão de uso observado por modelo. Eu não recalculei.

Modelo	Teto Go	Pedidos / 5 h	Pedidos / semana	Pedidos / mês
Muse Spark 1.3 / 1.2 Contributor	60	45.300	113.300	226.600
MiMo-V2.6-Flash e 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 e 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 e Grok 4.6	15	169	423	845
Qwen3.8 Max	15	160	400	810
Kimi K3	15	110	250	490

O Muse Spark 1.3 Contributor estima 226.600 pedidos por mês. O Kimi K3 estima 490. É o mesmo plano de 10 USD. Quem usar o Go como buffet de «sempre o modelo de nome maior» enche a janela de 5 horas no primeiro dia. Num modelo de teto 15 USD essa janela são 3 USD, não 12.

No Go Plus, o mesmo GLM-5.3-Flash estima 18.960 pedidos a cada 5 horas, 47.370 na semana e 94.740 no mês. O Kimi K3 estima 440, 1.000 e 1.960. O Grok 4.7 estima 676, 1.692 e 3.380. O resto da tabela está na documentação do Go.

Uma tarefa agêntica de verdade — adicionar autenticação, escrever os testes e atualizar a documentação — não é um pedido. São entre 30 e 150 turnos. Com essa régua, 4.300 pedidos mensais do GLM-5.2 são entre 30 e 100 tarefas médias por mês. Para uma pessoa, sobra. Para quatro pessoas na mesma conta, não: só um membro por workspace pode assinar o Go ou o Go Plus.

Se o que você busca é um detalhamento focado só no preço e nos limites do Go, sem a parte do Zen nem de estratégia, tenho uma resenha dedicada: OpenCode Go: preço, limites de uso e se vale a pena em 2026.

O custo real por turno, para colocar as coisas em perspectiva

Para entender por que a estratégia que proponho funciona, ajuda calcular quanto custa um turno agêntico típico em cada modelo. Uso um perfil realista e constante — cerca de 800 tokens de entrada nova, 60.000 tokens lidos de cache (o contexto do repositório, que é o que domina o gasto) e 250 tokens de saída — e aplico os preços públicos do Zen:

Modelo	Custo 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

Estimativa própria de 12 de agosto de 2026, com o perfil descrito e os preços do Zen daquele dia. Não recalculei em 30 de setembro de 2026: o catálogo já inclui modelos mais novos e os preços se movem. Serve para ver a ordem de grandeza, não para orçar o mês.

O que salta aos olhos é que a diferença entre o modelo de fronteira e o modelo braçal não é de 30% nem do dobro: o Claude Fable 5 custa mais de quarenta vezes o que custam o GPT 5.6 Luna ou o DeepSeek V4 Flash pelo mesmo turno, e dentro do plano Go essa brecha se alarga ainda mais. E aqui vem a pergunta incômoda: será que esses 150 turnos de «leia o arquivo, aplique o diff, rode o teste» realmente precisam do melhor modelo do mundo?

Quase nunca. O que de fato precisa do melhor modelo do mundo é a decisão do que construir e como. E essa decisão são cinco ou dez turnos, não cento e cinquenta.

Minha recomendação: separe o design da execução

Aqui está o núcleo do artigo. Meu fluxo, depois de bastante tentativa e erro, é este: defino o spec com Claude ou Grok, e executo o spec com o OpenCode Go.

Pessoalmente uso sobretudo o Claude — Opus 5 quando a decisão é arquitetural e Sonnet 5 para specs mais rotineiros — e o Grok quando quero uma segunda opinião com um viés diferente ou quando preciso que o modelo seja direto e não complacente. O Codex funciona igualmente bem para essa fase se for a sua ferramenta habitual; o ponto não é a marca, é o papel.

A lógica é a mesma que aplicamos em qualquer metodologia ágil séria: o refinamento e a execução são atividades distintas, com custos e perfis de risco distintos. Ninguém põe o arquiteto para escrever os testes unitários, e ninguém pede ao júnior que decida o modelo de dados. Quando você mistura as duas coisas numa única conversa com um modelo de fronteira, paga preço de arquiteto por trabalho de execução durante horas.

Por que isso funciona tecnicamente

Um modelo de execução não precisa de criatividade; precisa de obediência e competência. Se o spec é bom — se diz quais arquivos tocar, qual contrato cumprir, quais casos de borda cobrir e como se verifica o sucesso — então a tarefa deixa de ser «projete isto» e passa a ser «transcreva isto em código e valide». Modelos como GLM-5.2 ou Kimi K2.7 Code fazem isso perfeitamente bem.

Quando o spec é ruim, por outro lado, o modelo de execução começa a improvisar. E é aí que as pessoas concluem que «os modelos abertos não prestam». Não é que não prestem: é que você pediu para eles fazerem dois trabalhos e só pagou por um.

O fluxo concreto, passo a passo

1. Conversa de design com Claude ou Grok. Ainda sem código. Descreva o problema, o contexto do negócio e as restrições. Peça explicitamente que ele te faça perguntas antes de propor. Aqui você gasta entre 5 e 15 turnos de um modelo caro, e são os turnos mais bem investidos do processo.

2. Gere o spec como arquivo. Peça a saída em markdown, com esta estrutura mínima: objetivo, contexto (o que existe hoje), escopo explícito, fora de escopo explícito, arquivos a tocar, contratos e interfaces, casos de borda, critérios de aceitação verificáveis e plano de verificação. Guarde no repositório, por exemplo em specs/2026-08-12-auth-jwt.md. Viver no git faz parte do ponto: é documentação e é rastreabilidade.

3. Divida em tarefas atômicas. Cada tarefa do spec deve ser algo que um agente consiga completar e verificar sem ambiguidade. Se uma tarefa precisa de uma decisão de produto no meio do caminho, não está pronta para ser executada; volte ao passo 1.

4. Execute com o OpenCode Go. Abra o OpenCode no repositório, aponte o spec e deixe o modelo braçal trabalhar. A minha atribuição padrão é GLM-5.2 ou Kimi K2.7 Code para a implementação principal, MiniMax M3 ou DeepSeek V4 Flash para tarefas mecânicas (renomear, migrar sintaxe, gerar testes repetitivos, atualizar imports).

5. Revisão com o modelo caro, só se for preciso. Se os testes passam e o diff é legível, não precisa. Se algo cheira estranho, passe o diff ao Claude ou ao Grok com a pergunta concreta. São três turnos, não trinta.

Exemplo de spec executável

# Spec: Rate limiting no endpoint público de busca

## Objetivo
Evitar abuso do endpoint `GET /api/search`, hoje sem proteção.

## Contexto
- Express 4 + Redis já disponível em `src/lib/redis.ts`
- Middleware de auth em `src/middleware/auth.ts` (padrão a imitar)
- Ainda não há testes de middleware

## Escopo
- Middleware `rateLimit` reutilizável, configurável por rota
- Aplicá-lo apenas a `GET /api/search`
- Janela deslizante no Redis, 60 requisições / 60s por IP
- Responder 429 com header `Retry-After`

## Fora de escopo
- Rate limiting por usuário autenticado (fase 2)
- Dashboard de métricas
- Mudanças no algoritmo de busca

## Arquivos
- Criar: `src/middleware/rateLimit.ts`
- Criar: `src/middleware/__tests__/rateLimit.test.ts`
- Modificar: `src/routes/search.ts` (apenas adicionar o middleware)

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

## Casos de borda
- Redis caído → deixar a requisição passar e logar um warning (fail-open)
- IP ausente na requisição → usar `req.socket.remoteAddress`, e se também não houver, não limitar
- Relógio: usar `Date.now()` do servidor, não timestamps do cliente

## Critérios de aceitação
- [ ] 60 requisições em 60s passam; a 61ª devolve 429
- [ ] O header `Retry-After` traz segundos até o reset
- [ ] Com Redis caído, os testes seguem no verde
- [ ] `npm test` e `npm run lint` no verde
- [ ] Nenhum arquivo fora da lista de "Arquivos" fica modificado

## Verificação
Executar `npm test -- rateLimit` e `npm run lint`.

Um spec assim o GLM-5.2 executa sem despentear o cabelo, provavelmente em 25-40 turnos. A ~0,014 dólares de orçamento Go por turno, falamos de meio dólar da cota mensal de 60 desse modelo. Você pode fazer isso mais de cem vezes por mês.

Escolher a IA conforme a necessidade e a complexidade

Este é o hábito que mais economiza — dinheiro e frustração — e o que menos gente cultiva. A pergunta certa antes de abrir qualquer chat não é «qual é o melhor modelo?», e sim «que tipo de trabalho é este?».

Eu penso nisso em quatro níveis.

Nível 0 — Mecânico. Renomear variáveis, converter um formato em outro, gerar boilerplate, traduzir um arquivo de configuração, escrever testes repetitivos a partir de um padrão já estabelecido. Não há decisões. Use um modelo de teto alto e muitos pedidos: MiMo-V2.6-Flash, DeepSeek V4.1 Flash ou MiniMax M2.7. Se o resultado sair errado, você percebe na hora e tentar de novo gasta pouco desse teto.

Nível 1 — Implementação guiada. Há um spec claro e é preciso transformá-lo em código que compile, passe nos testes e respeite as convenções do projeto. Exige competência real, mas não julgamento de produto. Aqui moram GLM-5.2, Kimi K2.7 Code, MiniMax M3, Qwen3.7 Plus. É 70% do trabalho real de programar e é exatamente o terreno do Go.

Nível 2 — Design delimitado. É preciso decidir algo, mas dentro de um quadro conhecido: como modelar esta tabela, qual padrão usar para este caso, como estruturar este módulo. Aqui a régua sobe: Grok 4.7, Claude Sonnet 5 ou um modelo da mesma classe no Zen. São poucos turnos, então mesmo que custem mais, o impacto na fatura é menor do que você teme. No Go, o Grok 4.7 tem teto mensal de 15 USD.

Nível 3 — Decisão com consequências. Arquitetura, estratégia de migração, escolha de tecnologia, análise de um incidente confuso, qualquer coisa em que errar custa semanas. Modelo de fronteira, sem hesitar: Claude Opus 5, Claude Fable 5, GPT 5.6 Sol, Gemini 3.1 Pro. E aqui vale o luxo da segunda opinião: fazer a mesma pergunta a dois modelos de famílias diferentes e comparar. Quando os dois concordam, você tem um sinal razoável; quando divergem, você encontrou exatamente o ponto em que precisava pensar por conta própria.

A regra que resume tudo: o modelo caro decide, o modelo barato executa. E o corolário, que é igualmente importante: se você se pegar usando um modelo de fronteira no octogésimo turno da mesma tarefa, alguma coisa deu errado na etapa de design. Volte ao spec.

Há uma nuance que vale a pena explicitar, porque toca a parte filosófica de tudo isso. A tentação de usar sempre o melhor modelo não é econômica, é psicológica: dá mais sensação de segurança. Mas essa sensação de segurança tem um preço real, e não é só o da fatura. Quando você delega tudo ao modelo mais capaz, deixa de distinguir entre as decisões que importam e as que não importam. Obrigar-se a classificar a tarefa antes de escolher a ferramenta é, no fundo, um exercício de critério. E o critério é a única coisa que não se pode terceirizar.

Dez dicas práticas para espremer o plano Go

1. Configure o seu modelo padrão para o braçal, não para o caro. No seu opencode.json, deixe opencode-go/glm-5.2 ou opencode-go/kimi-k2.7-code como modelo principal. Subir de nível deve ser um ato consciente, não o estado padrão.

2. Use o sistema de agentes do OpenCode para atribuir modelos por papel. O OpenCode permite definir agentes distintos com modelos distintos. Um agente plan com um modelo capaz que só lê e propõe, e um agente build com um modelo barato que executa. É o fluxo deste artigo, automatizado.

3. Escreva um AGENTS.md na raiz do repositório. Convenções, comandos de teste, estrutura de pastas, o que não tocar. Cada coisa que está ali é uma coisa que o modelo braçal não precisa adivinhar, e adivinhar é o que consome turnos.

4. Aproveite o cache. O grosso do custo por turno é leitura de cache, não tokens novos. Sessões longas sobre o mesmo contexto saem muito mais baratas por turno do que abrir uma sessão nova para cada tarefinha. Agrupe o trabalho relacionado.

5. Fique de olho na janela de cinco horas, não na mensal. Essa janela é 20% do teto daquele modelo: 12 USD se o teto é 60, e 3 USD se o teto é 15. Se a sessão vai ser intensa, comece por um modelo de muitos pedidos e reserve Grok 4.7 ou Kimi K3 para quando emperrar.

6. Ative "Use balance" só se tiver saldo Zen e souber por quê. É a válvula de escape: quando você esgota o Go, ele continua puxando do seu saldo de pagamento por uso em vez de travar. Muito útil num prazo apertado, perigoso se você deixar ativado e esquecer.

7. Ao esgotar o Go seguem os modelos gratuitos, com letra miúda distinta. No Go, Space Bunny Free e LongCat 2.5 Preview Free figuram sem teto pago por tempo limitado, e a tabela de privacidade do Go os marca a 0 dias e sem treinamento. No Zen, vários modelos grátis podem usar os dados para melhorar o modelo: Big Pickle, MiMo free, Ling e os endpoints gratuitos de Nemotron, entre outros. O Muse Spark Contributor, no Go e no Zen, troca preço por permissão de treinamento. Não mande código confidencial a um modelo que treina ou que retém.

8. Revise a tabela de privacidade antes de colocar código de cliente. No Go, a maioria figura a 0 dias. Grok 4.7, Grok 4.6, GPT 6 Luna e GPT 5.6 Luna retêm 30 dias. Muse Spark 1.3 e 1.2 Contributor autorizam o treinamento. O DeepSeek está a 0 dias com um acordo que a documentação dava por vigente até 31 de outubro de 2026. Se o código vai sob NDA, essa coluna importa mais do que o benchmark.

9. Tenha Zen com saldo mesmo usando o Go. Dez dólares de Go mais vinte de saldo Zen te dão o melhor dos dois: execução ilimitada na prática, e acesso pontual a modelos de fronteira quando a decisão justifica. Continua sendo menos do que custa uma única assinatura premium.

10. Meça. O console da OpenCode mostra o seu consumo. Olhe uma vez por semana durante um mês e você vai descobrir que 80% do seu gasto vem de dois ou três tipos de tarefa. São essas que precisam ir para modelos baratos ou, melhor, ser automatizadas com um spec reutilizável.

Ferramentas práticas que acompanham bem esse fluxo

OpenCode (opencode.ai) é a base: TUI, CLI, modo servidor, integração com IDE, suporte a MCP e a Agent Skills. Instalação em uma linha, funciona em macOS, Linux e Windows via WSL.

O comando /connect dentro da TUI é como você conecta o Go ou o Zen: ele pede a API key que você copia do console em opencode.ai/auth, e com /models você vê o catálogo disponível. Na sua configuração, os IDs levam o prefixo do provedor: opencode-go/kimi-k3 para o Go, opencode/gpt-5.6-sol para o Zen.

Claude Code, Codex CLI ou Grok para a fase de design. Qualquer um serve; o que importa é que a conversa do spec aconteça num lugar diferente do da execução, ainda que só para não misturar contextos.

Um diretório specs/ versionado no git. Parece pouco e é metade do valor deste método. Os specs se acumulam, são reaproveitados, viram modelos e — isso é o bom — se tornam o melhor onboarding possível para qualquer pessoa ou agente que chegue depois.

Servidores MCP para dar contexto real ao agente: acesso ao seu banco de dados, ao seu gerenciador de tarefas, à sua documentação. Um agente com contexto precisa de menos turnos, e menos turnos é menos orçamento consumido.

Os endpoints diretos do Go, se você quiser construir algo em cima. https://opencode.ai/zen/go/v1/chat/completions é compatível com o SDK da OpenAI, e alguns modelos expõem o formato da Anthropic em /v1/messages. Você pode usar a sua assinatura do Go a partir dos seus próprios scripts, não só pela TUI.

Quando o Go não é a resposta

Por honestidade, três cenários em que eu não o recomendaria.

Se o seu trabalho é majoritariamente de nível 3 — consultoria de arquitetura, pesquisa, análise — o Go vai te servir de pouco, porque o valor está nos modelos que ele não inclui. Pague o Zen por uso e pronto.

Se vocês são uma equipe, o Go não escala: só um membro por workspace pode assinar o Go ou o Go Plus. Para equipes, o caminho é um workspace do Zen com limites de gasto por membro e modelos habilitados conforme o papel.

E se o seu código for estritamente confidencial, revise a tabela de retenção modelo por modelo e considere BYOK com um provedor com quem você já tenha acordo contratual. Dez dólares é barato, mas não o suficiente para pular essa conversa.

Fechamento

A conclusão que levo depois de meses com esse fluxo não é sobre a OpenCode. É sobre como pensamos o gasto em IA de modo geral: continuamos comprando ferramentas quando o que deveríamos estar desenhando são processos.

Dez dólares por mês rendem muitíssimo se a execução chega com instruções claras, e rendem bem pouco se você os usa como substituto do pensamento. O plano Go não te torna mais produtivo por si só; ele te obriga — por design, através dos seus limites — a decidir o que merece um modelo caro e o que não merece. E essa disciplina, que parece uma restrição, acaba sendo o que faz o trabalho sair melhor.

Defina o spec com o melhor modelo que você conseguir pagar. Execute-o com o mais barato que aguentar. Guarde o spec no git. Repita.

O plano, se você quiser, está em OpenCode Go. É a página do produto: o programa de indicação acabou e esse link não credita saldo.

Perguntas frequentes

O OpenCode Go substitui o Claude Code ou o Codex?

Não, e não deveria. O Go é um plano de execução com modelos abertos. Claude Code e Codex continuam melhores para a fase de design e para tarefas que exigem julgamento. A proposta deste artigo é usá-los juntos, não escolher.

Posso ter Go e Zen ao mesmo tempo?

Sim. O Go cobre a execução dentro do catálogo dele. O Go Plus, a 40 USD, sobe a cota desses mesmos modelos. O Zen cobre o que o Go não inclui. Com "Use balance" ativado, ao chegar ao teto do Go os pedidos seguem contra o saldo Zen.

Quantas tarefas reais cabem no plano de 10 dólares?

Depende do modelo. O GLM-5.2 estima 4.300 pedidos por mês. Com tarefas de 30 a 150 turnos, são entre 30 e 100 tarefas médias. O DeepSeek V4 Flash estima 65.000 por mês no Go, e o MiMo-V2.6-Flash estima 150.400. O Kimi K3 estima 490. O plano não se comporta igual em todos.

Por que o Kimi K3 só estima 490 pedidos por mês no Go?

Porque o teto é por modelo. O Kimi K3 tem teto mensal de 15 USD no Go, não de 60. Grok 4.7 e Grok 4.6 também estão em 15 USD e estimam 845 pedidos por mês. Não é um multiplicador único de 6x aplicado ao catálogo inteiro. No Go Plus, o teto do Kimi K3 passa a 60 USD e a estimativa sobe para 1.960 pedidos por mês.

O que acontece se eu esgotar o limite?

Você pode continuar usando os modelos gratuitos do catálogo, ou ativar "Use balance" para puxar do seu saldo do Zen. Também pode esperar a janela de cinco horas reiniciar.

O OpenCode Go serve para equipes?

Não como cota compartilhada: só um membro por workspace pode assinar o Go ou o Go Plus. Para equipes, a via publicada é um workspace do Zen com papéis, limites de gasto por membro e controle de quais modelos se habilitam.

Os meus dados são usados para treinar?

Na tabela do Go de 29 de setembro de 2026, a maioria diz que não, com retenção de 0 dias. Grok 4.7, Grok 4.6, GPT 6 Luna e GPT 5.6 Luna retêm 30 dias e figuram como não usados para treinar. O Muse Spark Contributor autoriza o treinamento. No Zen, vários modelos grátis podem usar os dados para melhorar o modelo, e OpenAI e Anthropic retêm 30 dias. A lista de exceções está na documentação de cada produto.

Continue lendo

Se você quer só o preço, os limites e a minha experiência usando o OpenCode Go sozinho, sem a parte do Zen nem da estratégia de specs: OpenCode Go: preço, limites de uso e se vale a pena em 2026.

Se você tiver interesse no restante do panorama de provedores de IA para programar, além da OpenCode: Por que em 2026 você não deveria mais depender de um único provedor de IA para programar.

Fontes

Catálogo, tetos e pedidos estimados do Go verificados em 29 de setembro de 2026. Zen, recarga automática e exceções de privacidade verificados em 30 de setembro de 2026. A tabela de custo por turno é uma estimativa de 12 de agosto de 2026 e não foi recalculada. O catálogo muda; consulte a documentação antes de pagar.