Como usar o GPT-6 Astra para planejar e um modelo barato para executar

Pagar preço de modelo topo de linha pra IA renomear variável em 40 arquivos é dinheiro jogado fora

Fala aí, beleza? A OpenAI anunciou em 3 de setembro de 2026 o GPT-6 Astra, apresentado como o modelo mais capaz dela, voltado a trabalho ponta a ponta difícil: raciocínio complexo, código, uso de computador, pesquisa e criação de documentos

Só que "mais capaz" vem junto com "mais caro", e a maior parte do seu dia não é decisão difícil, é tarefa mecânica

Daí o padrão que vamos montar aqui: um modelo pensa, outro executa 🙂

Por que separar o modelo que pensa do modelo que executa

A ideia não é gambiarra de internet, tá na documentação da própria OpenAI

No guia de modelos do Agents SDK, a orientação é definir model por agente quando aquele especialista precisa de outro perfil de qualidade, latência ou custo

E a receita descrita é bem literal: um agente separado com modelo de raciocínio alto, chamado só quando necessário, e um modelo mais rápido e barato no agente principal

Se você já trabalhou em obra (ou já viu de longe), a analogia é essa: o arquiteto desenha a planta, a equipe levanta a parede

Formação Recomendada

Formação Claude Code

Domine Claude Code do absoluto zero até o avançado

• 120 aulas
• 4 projetos
• 9h 45min

Conhecer formação

Você não paga hora de arquiteto pra assentar tijolo, né?

E qual a diferença de preço, na prática?

O GPT-6 Astra custa US$ 10 por 1 milhão de tokens de entrada e US$ 50 por 1 milhão de tokens de saída

O GPT-5.6 Sol, flagship para trabalho profissional complexo, custa US$ 4 de entrada e US$ 20 de saída

O GPT-5.6 Terra, posicionado como equilíbrio entre inteligência e custo, fica em US$ 2 e US$ 12

E o GPT-5.6 Luna, otimizado para cargas sensíveis a custo e alto volume, sai por US$ 0,20 de entrada e US$ 1,20 de saída em contexto curto

Essa distância aumentou faz pouco tempo: em 30 de julho de 2026 a OpenAI anunciou no fórum de desenvolvedores um corte de preço na família GPT-5.6, com o Luna ficando 80% mais barato e o Terra 20% mais barato

O executor barato ficou ainda mais barato, o planejador continua caro

É exatamente aí que o padrão de dois modelos ganha sentido

O que você precisa antes de começar

Antes de sair configurando, três coisas:

• Acesso ao gpt-6-astra: e aqui vale um aviso honesto, em 4 de setembro de 2026 o rollout ainda é escalonado. Começou por empresas do Trusted Access Program, com prioridade para clientes corporativos do programa de cibersegurança Daybreak, e o acesso via API e pelos planos Plus, Pro, Business e Enterprise foi anunciado para os dias seguintes
• Um modelo barato escolhido pra execução: Sol, Terra ou Luna, dependendo de quanto raciocínio a etapa mecânica ainda exige
• A ferramenta onde o fluxo vai rodar: Agents SDK, Codex CLI ou Claude Code

Os números que interessam do Astra pra dimensionar o fluxo: 1.050.000 tokens de janela de contexto e 128.000 tokens de saída máxima

O ID do modelo na API é gpt-6-astra

Tome cuidado com uma coisa: cada uma dessas ferramentas tem a própria configuração

O que vale pro Codex não vale pro Claude Code, e vice versa

Passo a passo: montando o fluxo de dois modelos

1. Decida onde a tarefa se parte em duas

Antes de qualquer config, pega um fluxo real seu e marca com o dedo onde termina o pensar e começa o executar

Pensar é decidir arquitetura, escolher abordagem, quebrar o trabalho em etapas

Executar é aplicar, repetir, formatar, gerar o boilerplate que já foi decidido

O erro comum deste passo: cortar tarde demais. Se o modelo barato ainda precisa "decidir" alguma coisa no meio da execução, o corte tá no lugar errado

2. Configure o esforço de raciocínio do planejador

O GPT-6 Astra aceita reasoning.effort nos valores low, medium, high, xhigh e max

{
  "model": "gpt-6-astra",
  "reasoning": { "effort": "high" }
}

O erro comum deste passo: tentar passar none achando que economiza

O Astra não aceita o valor none, então essa "economia" só te devolve erro

3. No Agents SDK, defina o modelo por agente

A documentação orienta setar model no agente que precisa de outro perfil de qualidade, latência ou custo

Na prática: agente principal no modelo rápido e barato, agente especialista de raciocínio alto acionado só quando a tarefa pede

E tem um atalho útil: existe um default no nível do run, que sobrescreve vários agentes de uma vez

O erro comum deste passo: sair definindo modelo agente por agente e esquecer que o default do run passa por cima da sua intenção

4. No Codex CLI, use o config.toml e entenda a precedência

A configuração de usuário vive em ~/.codex/config.toml, e existe sobrescrita por projeto em .codex/config.toml, carregada apenas quando o projeto é confiável

Flags de CLI como --model e -c chave=valor sobrescrevem tudo em uma invocação, conforme a referência de configuração do Codex

Para subagentes, dá pra definir defaults na seção agents do config ou colocar model e model_reasoning_effort no próprio arquivo do agente customizado:

model = "gpt-6-astra"
model_reasoning_effort = "high"

Um valor explícito no spawn tem precedência sobre o default

O erro comum deste passo: esquecer que, sem configuração nenhuma, o subagente herda modelo e esforço do agente pai

Ou seja, você acha que a execução tá rodando barato e ela tá rodando no mesmo modelo caro do pai 😅

5. No Claude Code, use o alias opusplan

O Claude Code já empacotou esse padrão num alias

Segundo a documentação de configuração de modelo, o opusplan usa Opus no plan mode, pra raciocínio complexo e decisões de arquitetura, e troca automaticamente para Sonnet no modo de execução

Se você precisa da janela grande nas duas fases, existe o sufixo opusplan[1m], que força a janela de 1M fora dos planos com upgrade automático

O erro comum deste passo: supor que a config de um produto vale pro outro

Alias do Claude Code não existe no Codex, chave de TOML do Codex não existe no Agents SDK

Onde cortar a tarefa: exemplos práticos de divisão

A parte difícil do padrão não é técnica, é saber onde passar a tesoura

Alguns cortes que costumam ser limpos:

• Decisão de arquitetura e quebra do plano ficam no modelo de raciocínio: qual camada muda, em que ordem, o que quebra junto
• Refactor repetitivo vai pro barato: o plano já disse o que fazer, agora é aplicar em N arquivos
• Geração de boilerplate vai pro barato: rota, teste esqueleto, DTO, migration
• Formatação e extração estruturada vão pro barato: transformar texto solto em JSON com schema fixo é trabalho mecânico

Tem também o caso de escalada, que é o coração do padrão no Agents SDK: o agente de raciocínio alto não fica ligado o tempo todo, ele é chamado só quando necessário

O barato tenta, e quando a coisa trava ou a decisão fica ambígua, sobe pro caro

Vale a pena mapear com calma as tarefas em que o modelo barato entrega igual, porque cada uma delas é um pedaço da conta que some

E tem o inverso também: trabalho de leitura pesada, tipo entender um repositório legado sem documentação, é justamente o tipo de coisa que justifica o modelo caro

E se o modelo de planejamento não estiver disponível?

No Claude Code o opusplan tem um fallback documentado: se availableModels exclui o Opus mais novo mas permite uma versão anterior, ele usa o Opus permitido mais recente pra planejar

Só fica no Sonnet quando todo Opus está excluído

Detalhe pequeno, mas evita aquele susto de achar que o plan mode caiu de qualidade sem motivo

Quanto custa cada modelo: Astra, Sol, Terra e Luna

Essa é a base pra escolher o par planejador e executor

Onde tá n/d eu não confirmei o valor na página oficial de preços, então prefiro deixar em branco a chutar número

Repara na coluna de saída, que é onde o dinheiro some mais rápido

Execução costuma gerar MUITO token de saída (código, arquivo inteiro reescrito, lista longa), e é justamente a etapa que você move pro modelo barato

Armadilhas de custo que anulam a economia do padrão

Dá pra montar o fluxo direitinho e mesmo assim tomar susto na fatura

Três detalhes de faturamento que merecem atenção:

• Prompt gigante reprecifica tudo: acima de 272 mil tokens de entrada, a requisição inteira do Astra é reprecificada em 2x nas taxas de entrada e de cache e 1,5x na saída. Não é só o excedente, é a requisição inteira
• Fast mode dobra a conta: o Fast mode entrega até 2x a velocidade do Standard cobrando 2x o preço, enquanto Batch e Flex custam 50% das taxas Standard. Se a etapa não é interativa, o modo econômico resolve
• Residência de dados tem adicional: endpoints de processamento regional têm acréscimo de 10% para modelos lançados a partir de 5 de março de 2026 elegíveis a residência de dados

E tem o outro lado da moeda, que joga a favor: a entrada cacheada do Astra custa US$ 1,00 por 1 milhão de tokens, contra US$ 10 da entrada padrão

Como no padrão de dois modelos o plano tende a ser reaproveitado entre chamadas, esse é o tipo de detalhe que muda a matemática do fluxo inteiro

Já me ferrei com isso em outro contexto: mandar o mesmo bloco de contexto do zero, várias vezes, é a forma mais silenciosa de queimar orçamento

Conclusão

O padrão de dois modelos não é economizar cortando qualidade

É pagar caro só onde a decisão é difícil, e pagar barato onde o trabalho é mecânico

Próximo passo, bem prático: pega um fluxo repetitivo do seu dia, marca com o dedo onde termina o pensar e começa o executar, e configura o par de modelos na ferramenta que você já usa (Agents SDK, Codex CLI ou o alias opusplan do Claude Code)

E a nota honesta pra fechar: em 4 de setembro de 2026 o acesso ao GPT-6 Astra ainda estava em liberação escalonada, com API e planos pagos chegando por etapas

Então se o modelo ainda não apareceu pra você, monta a estrutura com o que dá e liga o planejador quando o acesso cair

até o próximo post! 😀