Conclusão em 5 segundos: mesmo usando o mesmo modelo, o consumo pode variar muito conforme o que você coloca no contexto a cada vez, quantas vezes chama o modelo, quanto resultado de ferramenta carrega junto e onde comprime o histórico. Se o modelo é o motor, ferramentas como Codex e OpenCode (o chamado "harness", ou arnês) são o câmbio, a injeção de combustível, o GPS e o mecânico, tudo junto. Motor igual não quer dizer consumo igual.
1. "Na mesma janela de 5 horas, rende o dobro": antes de tudo, isso é um relato pessoal, não um benchmark
Nas redes sociais, um desenvolvedor contou que trocou o Codex pelo OpenCode, usou o mesmo GPT-5.6 Sol com login do ChatGPT e sentiu que, dentro da mesma janela de 5 horas e do mesmo limite semanal, o trabalho andava mais que o dobro.
Nas respostas, teve quem indicasse outro arnês, o pi, quem desconfiasse de diferença na configuração do limite de contexto e quem quisesse ver o consumo real por meio de um roteador ou de telemetria (registro de uso).
O ponto mais importante aqui é que ninguém provou que "no OpenCode dá oficialmente para usar o dobro". É uma observação interessante, mas não um teste comparativo controlado.
Por outro lado, a OpenAI explica que o uso do Codex não é medido por um número fixo de mensagens: varia conforme o modelo, onde a tarefa roda, a complexidade, o contexto, o raciocínio, a velocidade, as ferramentas e assim por diante. Dependendo do plano, existem tanto a janela de 5 horas quanto a semanal.
Ou seja, o fenômeno "troquei de arnês e o consumo mudou" é bem natural, dado o jeito como tudo funciona.
2. O que é o arnês (harness)? Tudo o que fica fora do corpo da IA
Olhando só o modelo, a conversa é simples.
Sol = cérebro.
Mas um agente de programação de verdade carrega muito equipamento em volta desse cérebro:
- como as instruções de sistema (system instruction) são montadas
- quais arquivos são lidos
- quantos tokens da conversa passada ficam guardados
- quantas ferramentas são mostradas, como terminal e GitHub
- até onde a saída das ferramentas (tool output) é levada para o turno seguinte
- quantas vezes tenta de novo quando falha
- quantas rodadas de planejamento, implementação e revisão acontecem
- se comprime o histórico antes de o contexto estourar
- se divide o trabalho com subagentes
- quando decide que "terminou"
Esse conjunto todo é o arnês, no sentido amplo.
A própria OpenAI usa a palavra "harness" ao falar do Codex, ao descrever o App Server que liga o modelo aos clientes, às ferramentas e ao estado da conversa.
Por isso,
mesmo modelo ≠ mesmo sistema.
É como colocar o mesmo motor V8 num SUV de 2 toneladas e numa carroceria leve: o consumo não vai ser igual.
3. O vilão do consumo da IA costuma ser a "bagagem que vai junto a cada turno"
O consumo de um agente não depende só de quantos caracteres ele escreveu na resposta.
Numa sessão longa, cada raciocínio carrega junto:
- um histórico de conversa enorme
- um system prompt grande
- o AGENTS.md e as regras
- os esquemas de ferramentas (tool schema) do MCP
- muitos arquivos lidos do GitHub
- logs gigantes do terminal
- resultados de testes
- falhas anteriores
- informações para a próxima tentativa
Uma vez só, é leve.
O problema é reenviar e reinterpretar isso 10, 20, 30 vezes.
Às vezes pesa mais chamar o modelo várias vezes carregando um contexto de 100 KB do que simplesmente "ter lido 100 KB de log".
E mais: se o arnês A termina uma tarefa em 15 turnos e o arnês B gasta 30 turnos com planejar → confirmar → explorar → explorar de novo → revisar → revisar de novo, é claro que haverá diferença mesmo com o mesmo modelo.
O consumo não se perde só no desempenho do motor, mas em
bagagem × número de idas e vindas × número de novas tentativas.
4. Por que o OpenCode é interessante: login do ChatGPT, MCP e compactação na mesma caixa
Segundo a documentação oficial do OpenCode, ao conectar a OpenAI dá para escolher ChatGPT Plus/Pro e autenticar pelo navegador. É um caminho separado do de digitar a chave de API à mão.
Além disso, o OpenCode, como cliente MCP, aceita tanto MCP local quanto remoto.
Ou seja, dá para montar algo assim:
OpenCode → GitHub MCP → MCP de banco de dados → API própria → outras ferramentas externas
O OpenCode também tem compactação (compaction) automática, que troca o contexto ativo antigo de uma sessão longa por um checkpoint. Na documentação atual, a compactação automática vem ativada por padrão, e há um exemplo de configuração que mantém o resumo gerado e mais ou menos os últimos 15.000 tokens.
Isso é menos "apagar a conversa antiga" e mais
guardar o histórico no depósito e levar na próxima saída só a bagagem necessária.
Mas não é uma solução mágica. O próprio OpenCode avisa que, quanto mais servidores MCP você adiciona, mais contexto os esquemas de ferramentas e afins consomem, e que MCPs grandes, como o do GitHub, sobrecarregam o contexto com facilidade.
Conectar 20 MCPs e achar que "agora é o máximo!" é como equipar o depósito inteiro no inventário do herói.
5. Controlar tudo a partir do ChatGPT via MCP segue praticamente a mesma ideia
Colocar o ChatGPT no centro e operar GitHub, servidores, nuvem, armazenamento etc. por meio de MCP ou de conectores externos também é, na essência, "modelo + arnês + ferramentas".
No diagrama de ligações fica simples:
ChatGPT → MCP / conector → GitHub, servidores, nuvem, armazenamento
O ChatGPT decide, o MCP faz o papel de mãos e pés, e cada serviço guarda o estado do lado do mundo real.
No OpenCode é a mesma coisa:
OpenCode → MCP / terminal / API → repositório, servidor, nuvem
A diferença está em onde fica o estado da conversa, onde roda o ciclo de ferramentas (tool loop) e onde o contexto é comprimido.
Então, à pergunta "é a mesma coisa que comandar tudo do ChatGPT via MCP?", a resposta é: sim, em boa parte.
É a mesma filosofia de construção; só muda o nome do produto na sala de comando.
6. Dá para passar trabalho do ChatGPT para o OpenCode?
O OpenCode oferece suporte oficial ao lado de "quem usa MCP". Já na documentação oficial que citei, em vez de um modo que exponha o próprio OpenCode como servidor MCP genérico, aparecem explicitamente um servidor HTTP/OpenAPI com SDK e a porta de entrada ACP.
Com o opencode serve, é possível subir o OpenCode como servidor HTTP headless (sem interface) e controlar sessões e agentes por programa via OpenAPI. Também existe um SDK em JS/TS.
Portanto, se você quer mandar trabalho do ChatGPT para o OpenCode, o arranjo limpo é este:
ChatGPT → ponte MCP fina → OpenCode Server → Sol → MCP / terminal / API → GitHub, nuvem etc.
As ferramentas que a ponte MCP expõe podem ser pouquíssimas:
- opencode_run_task
- opencode_get_status
- opencode_get_result
Já bastam.
Em vez de levar para o lado do ChatGPT, a cada vez, dezenas de esquemas de ferramentas do GitHub e logs enormes, o trabalho longo termina dentro do OpenCode e só o resultado final volta.
É aí que "melhorar o consumo" vira projeto de verdade.
7. Para reduzir o consumo a sério, gaste menos "voltas para a IA", e não menos IA
O erro mais comum é achar que trocar por um modelo mais barato resolve tudo.
Claro que a escolha do modelo importa.
Mas, em trabalho automático de longa duração, funciona ainda mais uma separação como esta:
- Tirar o que é determinístico e passar para scripts
- Deixar o estado (state) e os recibos (receipt) do lado da máquina
- Ativar só as ferramentas necessárias
- Resumir ou extrair o que importa dos logs longos antes de entregar ao modelo
- Não reler o mesmo arquivo várias vezes
- Salvar como estado o motivo da falha e a próxima ação (next action)
- Devolver ao modelo mais potente só as decisões ambíguas
- Devolver aos humanos apenas a conferência final em produção (production readback)
O desenho ideal é:
IA = quem lida com a ambiguidade
script / workflow = quem executa o procedimento já definido
GitHub / banco de dados / estado = quem guarda a memória
Se você faz a IA pensar "o que eu faço agora mesmo?" a cada vez, toda vez começa um inventário do depósito.
Se a máquina já deixou o nextAction escrito, a IA só precisa ser chamada quando for necessário.
8. Mas ainda não dá para dizer que "no OpenCode, na mesma janela, sempre se ganha"
O que dá para confirmar na documentação oficial da OpenAI é que o Codex e o Work compartilham o mesmo limite de uso, que há janela de 5 horas e semanal conforme o plano e que o uso varia com o contexto, as ferramentas e outros fatores.
O que dá para confirmar na documentação oficial do OpenCode é que se pode usar a autenticação ChatGPT Plus/Pro.
Só que não existe, em nenhum dos dois materiais oficiais, uma tabela comparativa dizendo se o uso do OAuth do ChatGPT via OpenCode é consumido do lado da OpenAI pela mesma fórmula de medição e pelos mesmos coeficientes internos do Codex, nem quantas vezes mais se ganha com o OpenCode.
Portanto,
"Rendeu o dobro" é um relato medido interessante.
"Sempre rende o dobro" não está confirmado.
Convém não misturar as duas coisas.
Para comparar de verdade, use o mesmo repositório, o mesmo modelo, a mesma tarefa e a mesma condição de término, e registre:
- total de chamadas ao modelo
- tokens de input/output
- número de compactações
- número de chamadas de ferramentas
- tempo real decorrido (wall-clock time)
- quantidade de mudanças concluídas
- número de novas tentativas
- resultado final dos testes
O que importa não é "por quantas horas deu para usar", e sim o que foi consumido por tarefa concluída com sucesso.
Esse é o consumo de verdade.
9. Conclusão: na era da IA, depois da escolha do modelo, o que mais pesa é a "fiação"
Antes, o centro da conversa era "qual modelo é o mais inteligente".
Na era dos agentes, isso não basta.
Mesmo com o mesmo modelo, a quantidade de trabalho muda conforme
- como o contexto é preenchido
- o número de ferramentas
- a gestão de estado
- a compactação
- as novas tentativas
- o critério de término
- a divisão de tarefas com workflows externos
O modelo é o motor.
O arnês é o sistema que reúne injeção de combustível, câmbio, GPS, equipe de box e até o tamanho do porta-malas.
Então "como pode ser o mesmo Sol e render tão diferente?" é, ao contrário, uma dúvida bem natural.
E, no instante em que você começa a ligar vários serviços por MCP, o que está fazendo deixa de ser "usar a IA" e passa a ser
projetar um local de trabalho em volta da IA.
Por fim, a verdade mais direta: o MCP mais poderoso não é "perguntar tudo à IA".
É aumentar as etapas que não precisam perguntar nada à IA.
Referências
- OpenAI, Unlocking the Codex harness: how we built the App Server https://openai.com/index/unlocking-the-codex-harness/
- OpenAI Help Center, Usar o Codex com os planos do ChatGPT https://help.openai.com/ja-jp/articles/11369540
- OpenAI Help Center, Gerenciar o uso do GPT-6 Astra no Work e no Codex https://help.openai.com/ja-jp/articles/20001516-managing-usage-with-gpt-6-astra-in-work-and-codex
- OpenCode Docs, Providers https://opencode.ai/docs/providers
- OpenCode Docs, MCP servers https://opencode.ai/v2/docs/mcp-servers
- OpenCode Docs, Compaction https://opencode.ai/v2/docs/compaction
- OpenCode Docs, Server / SDK https://dev.opencode.ai/docs/server/ https://dev.opencode.ai/docs/ja/sdk/
- OpenCode Docs, ACP https://opencode.ai/v2/docs/cli/acp/
