GPT-6 Luna vs. GPT-5.6 Luna: como calcular o custo real de uma tarefa aceita no Codex

Você não precisa decidir qual geração Luna parece mais nova, mas qual modelo deve executar o próximo lote de tarefas do Codex e quando trocar depois de uma falha. Ao final, você poderá escolher o primeiro candidato pelo custo por tentativa e calcular o custo real de cada tarefa aceita com taxa de aceitação, novas tentativas e tempo de correção manual.

Comece por aqui: teste gpt-6-luna primeiro na maioria das tarefas verificáveis automaticamente

gpt-6-luna é o melhor primeiro candidato quando o escopo está claro e testes, lint ou um script de aceitação conseguem rejeitar rapidamente um resultado ruim. O custo menor por tentativa permite criar uma linha de base barata e decidir depois se o trabalho complexo deve passar para gpt-5.6-luna.

Sua situação	O que fazer primeiro	O que mudaria a recomendação
Correções pequenas ou mudanças em lote com testes automáticos	Comece com gpt-6-luna	Ele falha repetidamente ou a correção manual elimina a vantagem de preço
Recursos entre arquivos, refatorações ou mudanças de interfaces	Rode testes pareados com os dois modelos	Use gpt-5.6-luna nessa classe se reduzir claramente tentativas e correção
A entrada está perto ou acima de 272K	Remova arquivos irrelevantes, reduza o histórico ou divida a tarefa	Se não puder reduzir o contexto, compare com tarifas de contexto longo
Você usa franquia de plano ChatGPT ou Codex	Consulte o painel do plano e as regras de Credit, não a tabela de API	Aplique os preços por token apenas ao usar API Key ou custom provider

As informações públicas ainda não trazem resultados pareados na mesma versão do Codex, repositório e reasoning effort. O preço pode definir a ordem do teste, mas seus próprios dados devem definir o modelo padrão.

Os limites de interface são parecidos e não preveem a qualidade do código

Os dois modelos têm interfaces principais e limites de contexto parecidos, portanto a ficha técnica não mostra qual será mais confiável no seu código. Ambos aceitam texto e imagem, retornam texto, suportam Responses API, reasoning tokens e reasoning effort de none a max; ambos têm contexto de 1,050,000 tokens, máximo de 922,000 tokens de entrada e 128,000 de saída.

Item	gpt-6-luna	gpt-5.6-luna
Posicionamento oficial	Modelo eficiente para tarefas focadas e de alto volume	Modelo para cargas de alto volume sensíveis a custo
Data de corte do conhecimento	2026-05-18	2026-02-16
Janela de contexto	1,050,000 tokens	1,050,000 tokens
Reasoning effort padrão	medium	medium

Essas especificações não provam que um modelo terá maior taxa de aceitação, concluirá mais rápido ou exigirá menos tentativas no seu código. O resultado do Codex também depende do tipo de tarefa, qualidade do contexto, permissões das ferramentas, versão do cliente, reasoning effort e critérios de aceitação.

Até 272K, gpt-6-luna tem tarifas por token menores

Com contexto completo de entrada de até 272K, gpt-6-luna custa metade em entrada, leitura e escrita de cache, enquanto a saída custa cerca de 41.7% de gpt-5.6-luna. A tabela foi verificada em 2026-09-25, usa USD por 1 milhão de tokens e compara apenas OpenAI Standard com cobrança de API da BetterToken, sem franquias de planos ChatGPT ou Codex nem cobrança por Credit.

Até 272K: calcule diretamente com esta tabela

Use esta faixa diretamente quando o contexto completo de entrada de cada solicitação ficar em 272K ou menos; não aplique os multiplicadores de contexto longo.

Model ID	Provedor	Entrada	Leitura de cache	Escrita de cache	Saída
gpt-6-luna	OpenAI Standard	$0.10	$0.01	$0.125	$0.50
gpt-6-luna	BetterToken	$0.068	$0.0068	$0.085	$0.34
gpt-5.6-luna	OpenAI Standard	$0.20	$0.02	$0.25	$1.20
gpt-5.6-luna	BetterToken	$0.136	$0.0136	$0.17	$0.816

Os preços da BetterToken são dinâmicos. Portanto, consulte os preços atuais no dia da publicação ou compra e use os valores exibidos naquele momento. A BetterToken não é um produto da OpenAI. As tarifas acima são do grupo GPT usado via API, Codex e ferramentas que aceitam Base URL personalizado; elas não são franquias de assinatura do ChatGPT ou Codex.

OpenAI Batch e Flex custam 50% do Standard para esses modelos, portanto ficam abaixo das tarifas da BetterToken mostradas aqui. Eles não fazem parte desta comparação. A tabela não deve ser interpretada como afirmação de que a BetterToken é mais barata que toda modalidade de processamento da OpenAI.

Acima de 272K: reduza a entrada primeiro e use tarifas longas se necessário

Se puder dividir a tarefa, remova arquivos irrelevantes, encurte o histórico ou separe o trabalho antes do limite, porque toda a solicitação fica mais cara. O limite usa o contexto completo de entrada, inclusive partes em cache; acima de 272K, entrada, leitura e escrita de cache custam 2 vezes a tarifa curta e a saída custa 1.5 vez:

Model ID	Provedor	Entrada	Leitura de cache	Escrita de cache	Saída
gpt-6-luna	OpenAI Standard	$0.20	$0.02	$0.25	$0.75
gpt-6-luna	BetterToken	$0.136	$0.0136	$0.17	$0.51
gpt-5.6-luna	OpenAI Standard	$0.40	$0.04	$0.50	$1.80
gpt-5.6-luna	BetterToken	$0.272	$0.0272	$0.34	$1.224

Separe quatro categorias de tokens para reproduzir o custo de uma tentativa

Para calcular uma tentativa do Codex, separe entrada sem cache, leitura de cache, escrita de cache e saída. O perfil hipotético comum abaixo demonstra o método; substitua os números pelos seus dados de cobrança para obter o custo real por tentativa:

• 32,000 tokens de entrada sem cache;
• 160,000 tokens lidos do cache;
• 16,000 tokens escritos no cache;
• 8,000 tokens de saída;
• contexto completo de entrada de até 272K em cada solicitação, portanto com tarifas de contexto curto.

A fórmula é:

Custo da tarefa = entrada sem cache / 1,000,000 × preço de entrada
                 + leitura de cache / 1,000,000 × preço de leitura
                 + escrita de cache / 1,000,000 × preço de escrita
                 + saída / 1,000,000 × preço de saída

Model ID	Provedor	Custo de entrada	Custo de leitura de cache	Custo de escrita de cache	Custo de saída	Total por tentativa
gpt-6-luna	OpenAI Standard	$0.003200	$0.001600	$0.002000	$0.004000	$0.010800
gpt-6-luna	BetterToken	$0.002176	$0.001088	$0.001360	$0.002720	$0.007344
gpt-5.6-luna	OpenAI Standard	$0.006400	$0.003200	$0.004000	$0.009600	$0.023200
gpt-5.6-luna	BetterToken	$0.004352	$0.002176	$0.002720	$0.006528	$0.015776

Com essa estrutura hipotética, uma tentativa de gpt-6-luna custa cerca de 46.6% de uma tentativa de gpt-5.6-luna. A BetterToken aplica o mesmo multiplicador de preço aos dois modelos, então a proporção entre eles é idêntica nos dois provedores. Ainda assim, esse é o custo por tentativa, não o custo por tarefa concluída com sucesso.

Calcule a leitura de cache à parte para não superestimar nem subestimar o custo

Não cobre leitura de cache como entrada comum nem a exclua da conta. O Codex relê contexto do repositório, histórico e resultados das ferramentas; tokens em cache costumam ser mais baratos, mas podem ser numerosos, então uma única cifra de “entrada” produz o cálculo errado.

Em cada execução, preserve separadamente input, cached input, cache write e output. Se uma camada de acesso mostrar apenas o valor final e não as quatro categorias, fica muito mais difícil explicar por que um modelo ou uma tarefa custou mais.

Escolha o modelo padrão pelo custo por tarefa aceita

Uma chamada barata não garante uma tarefa concluída barata; inclua o custo API de falhas, reversões e novas tentativas. A métrica mais útil é:

Custo por tarefa aceita = custo total de API de todas as tentativas / tarefas aceitas

Registre ao menos estas dimensões:

• Taxa de aceitação: proporção de tarefas que atendem aos critérios definidos sem o desenvolvedor reescrever a solução;
• Novas tentativas: prompts repetidos, reversões ou novas execuções do modelo para a mesma tarefa;
• Tempo total: do início até um diff aceitável, não apenas a latência do primeiro token;
• Correção manual: se o desenvolvedor precisou alterar o código gerado e por quanto tempo;
• Combinação de tokens: entrada sem cache, leituras de cache, escritas de cache e saída.

Com os custos hipotéticos do OpenAI Standard, a relação por tentativa é 0.010800 / 0.023200 ≈ 46.6%. Se o perfil de tokens permanecesse idêntico, gpt-6-luna ainda teria menor custo esperado de API sempre que sua taxa de aceitação fosse superior a aproximadamente 46.6% da taxa de gpt-5.6-luna. Isso é apenas uma relação de equilíbrio derivada de preços hipotéticos, não uma conclusão medida de qualidade. O limite muda quando tokens, tentativas ou tipos de tarefa mudam.

Fixe cinco condições antes de confiar na comparação

Executar cada modelo uma vez não é uma comparação válida; ambos precisam partir do mesmo estado, receber tarefas comparáveis e usar os mesmos critérios de aceitação. Estes cinco passos reduzem o viés de cache, ordem e julgamento humano.

1. Congele o ambiente

Use a mesma versão do Codex, commit inicial do Git, configuração, permissões das ferramentas, reasoning effort, prompt e comando de aceitação para os dois modelos. Não execute um via OpenAI Standard e o outro por um caminho diferente para depois atribuir toda diferença de latência ou falha ao modelo.

2. Separe as categorias de tarefa

Mantenha pelo menos três classes distintas:

Classe de tarefa	Exemplo	Critério de aceitação sugerido
Correção pequena	Defeito bem definido em um ou poucos arquivos	Testes específicos passam; arquivos não relacionados permanecem intactos
Alteração entre arquivos	Recurso, refatoração ou mudança coordenada de interfaces	Todos os testes e lint passam; o comportamento solicitado está presente
Revisão e diagnóstico	Encontrar um bug, explicar o risco e sugerir correção	Encontra o problema conhecido e aponta evidência concreta no código

Não reúna as três classes em uma única média. Dois modelos podem ser quase iguais em correções pequenas e diferir bastante na taxa de novas tentativas em mudanças entre arquivos.

3. Defina a aceitação antes de executar o modelo

Fixe de antemão os testes obrigatórios, diretórios permitidos, política de dependências e condições de falha. Reduzir o padrão após ver a saída torna a taxa de aceitação sem sentido.

4. Alterne a ordem dos modelos

Não execute sempre o mesmo modelo primeiro. Alterne a ordem ou use tarefas independentes equivalentes quando possível, para que cache da primeira execução, reparos de ambiente e familiaridade do operador não favoreçam sistematicamente um lado.

5. Preserve os registros por tarefa

Uma linha útil contém: ID, classe da tarefa, Model ID, provedor, camada de processamento, reasoning effort, hora inicial e final, as quatro categorias de tokens, número de tentativas, resultado, motivo da falha, minutos de correção manual e custo final. Guarde as linhas brutas antes de agregar por classe.

Quando manter gpt-6-luna e quando trocar para gpt-5.6-luna

Mantenha gpt-6-luna como candidato padrão enquanto a taxa de aceitação preservar a vantagem de preço e o tempo de correção manual for parecido. Se o resultado variar por classe de tarefa, faça roteamento em vez de impor um único modelo global.

O que você observa	Ação recomendada
A aceitação de gpt-6-luna supera cerca de 46.6% da aceitação de gpt-5.6-luna, com perfis de tokens e correção semelhantes	Mantenha gpt-6-luna; o custo esperado de API é menor
gpt-6-luna fica abaixo do ponto de equilíbrio, ou tentativas e correção tornam o total maior	Passe essa classe de tarefas para gpt-5.6-luna
gpt-6-luna ganha em correções pequenas, mas gpt-5.6-luna reduz retrabalho em mudanças entre arquivos	Faça roteamento por classe, sem escolher um default universal
A diferença vem principalmente de latência, erros ou limites do provedor	Repita pela mesma rota de acesso antes de atribuir a diferença ao modelo
A entrada passa frequentemente de 272K	Otimize o contexto e teste novamente; não confunda salto de tarifa com qualidade

O limite de 46.6% vale apenas para o perfil hipotético acima. Se comprimento da saída, cache ou número de tentativas mudarem, recalcule o ponto de equilíbrio com o custo real por tentativa de cada modelo.

Recomendação: crie a linha de base com gpt-6-luna e decida pelo custo de sucesso

Se precisar escolher um hoje, comece tarefas claras e verificáveis automaticamente com gpt-6-luna. Separe uma amostra representativa de tarefas complexas para rodar gpt-5.6-luna nas mesmas condições; não pare na comparação do preço de uma chamada.

Depois de um lote de tarefas comparáveis, calcule taxa de aceitação, média de tentativas, tempo de correção manual e custo por tarefa aceita. Mantenha gpt-6-luna como padrão se continuar mais barato; se gpt-5.6-luna eliminar retrabalho suficiente para cobrir sua tarifa maior em uma classe, encaminhe apenas essa classe para ele.

Referências oficiais

Use estas três páginas oficiais para conferir novamente as especificações e os preços da OpenAI.

• Página do modelo GPT-6 Luna
• Página do modelo GPT-5.6 Luna
• Preços da API da OpenAI