GPT-5.6 Sol, Terra e Luna: qual usar para programar

A OpenAI lançou o GPT-5.6 em três versões: Sol, Terra e Luna. À primeira vista parece só um nome novo para o de sempre, o caro, o médio e o barato. Só que a escolha entre eles muda mais o seu dia de trabalho do que parece, principalmente se você usa IA para programar.

O Sol é o de maior capacidade de raciocínio. O Terra fica no meio, tentando equilibrar inteligência e custo. O Luna foi feito para tarefas rápidas, repetitivas e em volume.

Essa é a resposta curta. Na prática, a pergunta certa não é qual é o melhor, e sim: quanto custa errar nessa tarefa, e quanto trabalho vai dar para conferir se a resposta está certa?

Trocar um texto num componente não pede o mesmo modelo que investigar um bug intermitente de autenticação, revisar uma migração de banco ou entender um monorepo com centenas de pacotes.

Resumo rápido: qual GPT-5.6 escolher?

A estratégia que funciona na maioria dos casos: comece no Luna ou no Terra e suba para o Sol quando a tarefa tiver ambiguidade, risco alto ou dependências espalhadas pelo projeto.

O que são Sol, Terra e Luna

O número 5.6 identifica a geração. Sol, Terra e Luna são níveis permanentes de capacidade, que podem evoluir de forma independente daqui para frente.

Comparando com as famílias anteriores, o Sol ocupa o lugar do modelo principal sem sufixo, o Terra fica mais ou menos onde estava o "mini" e o Luna onde estava o "nano".

Isso não faz do Luna um modelo fraco. Nos testes publicados ele chega perto ou supera modelos principais de gerações passadas em várias tarefas, e custa bem menos.

Comparação técnica

Na API, os três são parecidos nas especificações básicas:

Os IDs da API:

gpt-5.6-sol
gpt-5.6-terra
gpt-5.6-luna

O alias gpt-5.6 aponta para o Sol.

Mesmo contexto não é a mesma coisa que usar o contexto

Os três aceitam 1,05 milhão de tokens. Isso não quer dizer que os três consigam achar e relacionar informação espalhada por uma entrada gigante.

Numa avaliação da OpenAI com várias informações escondidas entre 512 mil e 1 milhão de tokens, o Sol marcou 73,8%, o Terra 72,5% e o Luna 41,3%.

Traduzindo: o Luna aceita o repositório inteiro, mas tem mais dificuldade para ligar detalhes distantes um do outro. Caber no contexto e entender o contexto são coisas diferentes.

GPT-5.6 Sol: quando errar sai caro

O Sol é o modelo mais capaz da família. Ele foi feito para trabalho profissional pesado: programação avançada, pesquisa, segurança, ciência, uso de ferramentas e tarefas que ficam rodando por muito tempo.

Em programação, ele compensa quando o problema pede investigação, não só geração de código.

Quando usar o Sol

• Investigar um bug intermitente que atravessa frontend, backend e infra.
• Entender uma base de código grande ou mal documentada.
• Planejar uma mudança de arquitetura.
• Revisar autenticação, pagamentos, permissões ou tratamento de dados sensíveis.
• Fazer migrações de banco de dados.
• Achar vulnerabilidades e sugerir correções.
• Implementar uma feature espalhada por vários pacotes.
• Trabalhar com agentes que rodam comandos, leem o resultado e corrigem a própria abordagem.
• Dar a última revisão antes de subir uma mudança arriscada para produção.

O Sol também costuma ser a melhor escolha quando a descrição do problema chega incompleta e o modelo precisa descobrir sozinho quais partes do sistema olhar.

Ele é realmente melhor para código?

No Artificial Analysis Coding Agent Index, que mistura implementação, uso de terminal e trabalho em repositórios reais, o Sol atingiu 80 pontos. O Terra marcou 77,4 e o Luna 74,6.

No Terminal-Bench 2.1, o Sol fez 88,8%, contra 87,4% do Terra e 84,7% do Luna. No DeepSWE, 72,7%, 69,6% e 67,2%.

A diferença existe. Ela só não é grande o bastante para justificar o Sol em qualquer coisa. Num ajuste de CSS, pagar pelo teto de inteligência não devolve um resultado proporcionalmente melhor.

GPT-5.6 Terra: o modelo do dia a dia

O Terra foi posicionado como o meio-termo entre inteligência e custo, e é provavelmente onde a maioria dos desenvolvedores vai passar a maior parte do tempo.

Ele custa metade do Sol por token e dá conta de features delimitadas, refatorações, revisões e debugging de várias etapas que não exijam o máximo de raciocínio.

Quando usar o Terra

• Desenvolver uma feature com requisitos claros.
• Refatorar componentes ou serviços.
• Transformar uma implementação síncrona em assíncrona.
• Revisar um pull request.
• Escrever testes para código que já existe.
• Investigar um bug que mora em poucos arquivos.
• Atualizar uma API ou biblioteca.
• Escrever queries SQL de complexidade média.
• Gerar planos de implementação.
• Trabalhar com agentes de programação ao longo de várias etapas.
• Implementar telas seguindo um design system que já existe.

No GitHub Copilot, o Terra aparece como a opção equilibrada para programação interativa e agentic coding do dia a dia. O Cursor também o indica para o trabalho corrente.

Ele deveria ser o padrão de todo mundo?

Não necessariamente. Numa análise independente da Artificial Analysis, certas configurações de Luna ou de Sol ficaram melhor posicionadas em custo e inteligência do que configurações equivalentes de Terra. Dependendo do nível de raciocínio, existe um Luna mais barato com resultado parecido, ou um Sol mais inteligente pelo mesmo custo total da tarefa.

Isso não torna o Terra inútil. Mostra só que preço por token não conta a história inteira. A quantidade de tokens gerados, o número de tentativas e o nível de raciocínio entram na conta final.

GPT-5.6 Luna: barato não é incapaz

O Luna é o mais rápido e o mais econômico. Foi criado para carga de trabalho de volume alto com custo controlado.

Para tarefas pequenas, bem explicadas e fáceis de verificar, ele costuma entregar a melhor relação entre custo e resultado.

Quando usar o Luna

• Renomear variáveis, funções e arquivos.
• Pequenos ajustes de HTML ou CSS.
• Gerar documentação.
• Explicar uma função.
• Resumir um pull request.
• Escrever mensagens de commit.
• Gerar nomes e esqueletos de testes.
• Criar mocks e dados de exemplo.
• Classificar erros ou tickets.
• Extrair informação estruturada de logs.
• Produzir boilerplate.
• Converter formatos de dados.
• Fazer uma pré-análise antes de mandar o problema para um modelo maior.
• Rodar automações repetitivas em volume.

O CodeRabbit sugere o Luna para resumos, explicações simples de código, sumários de pull request, checagens iniciais, nomes de teste e estrutura de changelog.

Dá para implementar features com ele?

Dá, desde que o escopo esteja fechado. Relatos de usuários do Codex indicam que o Luna resolve correções normais e features pequenas quando recebe instruções claras. Uma tática que circula na comunidade é usar Luna primeiro, Terra quando for preciso explorar mais partes do repositório, e Sol para arquitetura, autenticação, pagamentos ou migrações.

Esses relatos são anedóticos e recentes demais para virar regra, mas batem com os benchmarks: o Luna perde capacidade conforme a ambiguidade e o horizonte da tarefa crescem.

O nível de raciocínio pesa tanto quanto o modelo

Sol, Terra e Luna rodam em níveis diferentes de raciocínio:

none
low
medium
high
xhigh
max

Quanto mais alto o nível, mais tempo e mais tokens o modelo pode gastar analisando alternativas, rodando verificações e revisando a própria solução.

Isso produz resultados curiosos. No CursorBench 3.2:

• Luna High: 56,8%, custo médio de US$ 0,82 por tarefa.
• Terra High: 54,2%, custo médio de US$ 0,89.
• Sol Low: 52,6%, custo médio de US$ 1,01.

Nesse teste, subir o raciocínio do modelo barato saiu melhor e mais em conta do que usar um modelo maior com pouco raciocínio. A conclusão não é que Luna vence sempre. É que escolher só pelo nome do modelo é uma simplificação ruim.

A própria OpenAI recomenda começar no raciocínio médio, testar níveis mais baixos quando latência importa, e usar High, XHigh ou Max só quando uma avaliação real mostrar ganho. O Max fica para os trabalhos difíceis, não para tudo.

Qual a diferença entre Max e Ultra?

Nenhum dos dois é um modelo novo.

O Max deixa um modelo gastar mais computação procurando alternativas, rodando verificações e revisando a abordagem.

O Ultra usa quatro agentes em paralelo por padrão. Cada agente pode investigar uma parte diferente do problema antes de o sistema juntar os resultados.

No Terminal-Bench 2.1, o Sol normal marcou 88,8% e o Sol Ultra chegou a 91,9%. O ganho existe, mas vem com um consumo muito maior.

O Ultra faz sentido quando dá para dividir o trabalho:

• Analisar frontend, backend, banco e infra separadamente.
• Comparar propostas de arquitetura.
• Investigar hipóteses diferentes para um bug crítico.
• Planejar uma migração grande.
• Auditar uma base de código inteira.
• Quebrar uma pesquisa técnica em frentes independentes.

Para consertar um botão, criar um componente ou mexer numa query, Ultra é desperdício. Usuários do Codex relatam torrar uma fatia considerável dos limites numa única execução com Ultra. Como isso depende do plano e da tarefa, não vale como medição oficial, mas serve de aviso.

Quanto custa o GPT-5.6 na API

Preços publicados pela OpenAI, por 1 milhão de tokens:

Numa tarefa com 100 mil tokens de entrada e 20 mil de saída, sem cache, o Sol sai por volta de US$ 1,10, o Terra US$ 0,55 e o Luna US$ 0,22.

É só uma conta de padaria. Modelos diferentes gastam quantidades diferentes de tokens de raciocínio e podem precisar de mais ou menos tentativas até chegar numa solução aceitável.

Cuidado com entradas acima de 272 mil tokens

A janela vai até 1,05 milhão, mas requisições com mais de 272 mil tokens de entrada entram numa faixa de cobrança maior: a entrada é multiplicada por dois e a saída por 1,5, valendo para a requisição inteira. Mandar o repositório completo em toda chamada fica caro até no Luna.

Gravar o cache também custa. A gravação sai por 1,25 vez o preço normal da entrada, enquanto a leitura de tokens já armazenados mantém o desconto de 90%. Se o seu agente consulta as mesmas instruções, a mesma documentação e as mesmas partes do repositório o tempo todo, organizar bem o cache derruba o custo total.

Qual modelo usar em cada tarefa

Alterações pequenas e mecânicas

Luna Low ou Medium. Trocar textos, ajustar espaçamento, renomear símbolos, gerar documentação, criar mocks, converter JSON, resumir um diff.

Feature bem especificada

Comece no Luna High ou no Terra Medium. Escolha o Terra quando a feature tocar vários arquivos, depender de regra de negócio ou exigir alguma exploração do projeto.

Bug sem causa óbvia

Terra Medium para a primeira investigação. Suba para Sol Medium ou High quando aparecerem várias hipóteses, comportamento intermitente ou dependência entre sistemas.

Arquitetura, autenticação, pagamentos e migrações

Sol Medium ou High. Aqui uma resposta que parece certa pode plantar uma falha difícil de achar depois. O custo maior do modelo é pequeno perto do custo de uma implementação errada.

Revisão de código

Luna para a triagem, Terra para a revisão normal, Sol para as mudanças críticas. Um fluxo que funciona bem:

Luna: resume o diff e aponta áreas de risco
Terra: revisa lógica, testes e possíveis regressões
Sol: analisa só os pontos críticos encontrados

Frontend e interfaces

Para ajustes pequenos, Luna resolve. Para componentes completos e telas seguindo um sistema existente, o Terra costuma ser a melhor escolha. O Sol entra quando a tarefa envolve decisão visual, responsividade complicada, muitos estados ou inspeção do resultado renderizado.

A orientação oficial para o GPT-5.6 é preservar componentes, tokens de design e padrões existentes, não adicionar elementos que ninguém pediu, e renderizar a interface antes de dar a tarefa por encerrada.

Comece pequeno e suba quando precisar

O roteamento básico:

Luna → Terra → Sol

Só que não vale subir de modelo só porque a primeira resposta veio ruim. Antes, confira se o prompt informa o resultado esperado, os critérios de aceite, os arquivos relevantes, as restrições técnicas, os comandos de validação e o que não pode ser alterado.

Boa parte das falhas que a gente atribui ao modelo vem de requisito que faltou ou de instrução que se contradiz. Quando o prompt está completo e o modelo continua errando, aí sim faz sentido subir de Luna para Terra, ou de Terra para Sol.

Exemplo de roteamento na API

Uma aplicação pode escolher o modelo por escopo, risco e ambiguidade:

import OpenAI from "openai";

const openai = new OpenAI();

type CodingJob = {
  prompt: string;
  scope: "small" | "medium" | "large";
  risk: "low" | "medium" | "high";
  ambiguous?: boolean;
};

function selectModel(job: CodingJob) {
  if (job.risk === "high" || job.scope === "large") {
    return {
      model: "gpt-5.6-sol",
      effort: "medium" as const,
    };
  }

  if (job.ambiguous || job.scope === "medium") {
    return {
      model: "gpt-5.6-terra",
      effort: "medium" as const,
    };
  }

  return {
    model: "gpt-5.6-luna",
    effort: "low" as const,
  };
}

async function runCodingJob(job: CodingJob) {
  const selected = selectModel(job);

  const response = await openai.responses.create({
    model: selected.model,
    reasoning: {
      effort: selected.effort,
    },
    input: job.prompt,
  });

  return response.output_text;
}

Em produção esse roteador precisa ser calibrado com as tarefas reais da sua aplicação. Classificar só pelo tamanho do prompt funciona pior do que avaliar risco, ambiguidade, histórico de falhas e o custo da revisão humana.

Como escrever prompts melhores para o GPT-5.6

O GPT-5.6 não precisa de prompt gigante. Ele aproveita melhor instruções objetivas e critérios verificáveis. Uma estrutura que funciona:

Objetivo:
O que deve ser entregue.

Contexto:
Arquivos, tecnologias e comportamento atual.

Critérios de aceite:
O que precisa funcionar ao final.

Restrições:
O que não pode ser alterado.

Validação:
Testes, lint, build e comandos que devem ser executados.

Saída:
Como o resultado deve ser apresentado.

Para programação, peça explicitamente que o modelo:

1. Inspecione a implementação existente antes de alterar.
2. Preserve padrões e APIs públicas.
3. Rode os testes relacionados à mudança.
4. Execute type checking, lint e build quando fizer sentido.
5. Diga quais verificações não conseguiu rodar.
6. Não declare sucesso sem mostrar evidência da validação.

Essas práticas estão na própria orientação de prompts da OpenAI para o GPT-5.6.

Onde cada modelo está disponível

Depende do produto. Nas conversas normais do ChatGPT, quem tem plano elegível acessa o Sol pelos níveis Médio, Alto e Extra alto. Terra e Luna não aparecem como opção ali.

No ChatGPT Work e no Codex, usuários Plus, Pro, Business e Enterprise escolhem entre os três. Usuários Free e Go recebem o Terra em determinados produtos.

Na API da OpenAI, os três estão disponíveis direto. A família também está chegando ao GitHub Copilot e ao Cursor, com acesso variando conforme o plano e a liberação gradual.

Então qual é o melhor?

Não tem vencedor absoluto.

O Sol é o melhor quando você quer aumentar a chance de acertar um problema difícil de primeira. O Terra é a escolha mais equilibrada para o desenvolvimento cotidiano, quando o escopo não é trivial mas também não exige o teto. O Luna é o mais eficiente para tarefas pequenas, bem definidas e repetitivas.

Para quem programa, o melhor não costuma ser escolher um modelo, e sim montar um fluxo:

Luna para executar
Terra para investigar
Sol para decidir

E nada disso precisa ser rígido. Um Luna com raciocínio alto pode passar por cima de um Terra com raciocínio baixo, e um Terra bem orientado resolve tarefa que parecia coisa de Sol.

No fim, o modelo mais barato não é o de menor preço por token. É o que entrega uma resposta correta e verificável com menos tentativa e menos retrabalho.

Perguntas frequentes

Qual é o melhor GPT-5.6 para programar?

O Sol tem o maior teto de capacidade e vence nos problemas complexos. Para o dia a dia, o Terra oferece uma relação melhor entre desempenho e custo. Para tarefas pequenas e bem definidas, o Luna já resolve.

O GPT-5.6 Luna consegue criar aplicações?

Sim, quando os requisitos estão claros. Ele implementa aplicações pequenas e features delimitadas sem problema. Projetos grandes, ambíguos ou com decisões de arquitetura pedem Terra ou Sol.

Vale usar Sol em tudo?

Não. Alterações simples não aproveitam a capacidade extra. Guarde o Sol para problemas difíceis, mudanças críticas ou situações em que uma implementação errada sairia cara.

Qual a diferença entre Sol Max e Sol Ultra?

O Max deixa um único modelo raciocinar por mais tempo. O Ultra coordena vários agentes em paralelo, quatro por padrão. O Ultra consome bem mais e só compensa quando a tarefa pode ser dividida em frentes independentes.

Terra é sempre melhor que Luna?

Não. O Terra tem mais capacidade geral, mas um Luna configurado com raciocínio alto pode superar uma configuração mais econômica de Terra em certas tarefas. A escolha depende da dificuldade, do nível de raciocínio e do custo total da execução.

Os três suportam 1 milhão de tokens?

Sim, os três têm janela de 1,05 milhão de tokens na API. Só que eles não trabalham com a mesma qualidade quando a informação está espalhada por um contexto muito longo.

Dá para selecionar Terra ou Luna no ChatGPT?

Nas conversas padrão, não. Dependendo do plano, eles aparecem no ChatGPT Work, no Codex e na API da OpenAI.