GPT-6 Astra: o que realmente muda para quem faz engenharia

Em 3 de setembro de 2026 a OpenAI lançou o GPT-6 Astra, e apresentou o modelo como o início da "era da AGI". Vou deixar esse enquadramento de lado, porque é a parte menos útil do lançamento. O que importa para quem entrega software é mais estreito e bem mais concreto: o modelo ficou consideravelmente melhor em operar um computador, e custa cinco vezes mais por token do que o modelo que a maioria dos times roda hoje.

Na API é gpt-6-astra: janela de contexto de 1.050.000 tokens (922 mil de entrada, 128 mil de saída), corte de conhecimento em 30 de abril de 2026, entrada de texto e imagem, e cinco níveis de esforço de raciocínio, de low até max. Vem com ferramentas hospedadas para busca na web, busca em arquivos, code interpreter, um shell hospedado, apply patch, computer use e MCP.

Essa lista de ferramentas é a manchete de verdade. A aposta não é que o modelo escreve textos melhores. A aposta é que você entrega uma tarefa de várias etapas atravessando navegador, terminal e código, e sai de perto.

Comparado ao antecessor GPT-5.6 Sol, os saltos são reais e estão concentrados exatamente onde se espera que um modelo agêntico melhore:

Terminal-Bench saindo de 37,3% para 57,7% é o número que eu usaria para planejar. É o indicador mais próximo de "isso consegue terminar uma tarefa real em um shell real sem eu ficar supervisionando", e 20 pontos de ganho mudam o que você aceita delegar. O resultado de OSWorld vem com um segundo dado tão importante quanto a acurácia: cerca de 47% menos tempo por tarefa. Agente preciso mas lento continua sendo um problema de supervisão.

A manchete que todo mundo citou foi 99,9% no ARC-AGI-3. Trate esse número com cuidado: ele exige um harness com estado e caro, e chamadas stateless de API pontuam bem menos. Do mesmo jeito, 100% no ExploitBench diz mais sobre o benchmark estar saturado do que sobre o modelo estar pronto. Benchmark saturado deixa de ser medição e vira marketing.

Toda vez que a janela de contexto cresce, aparece o mesmo reflexo: parar de construir retrieval e jogar tudo no prompt. Com o Astra esse reflexo é caro o suficiente para virar decisão de arquitetura em vez de conveniência.

// A 1M-token context is a budget, not a target.// At $10 per million input tokens, one "just dump the repo in" call costs// about $9.22 at the 922k input ceiling — before a single output token.const INPUT_PER_MTOK = 10;const OUTPUT_PER_MTOK = 50;const CACHED_INPUT_PER_MTOK = 1; function costUSD({ fresh, cached, output }) {  return (    (fresh / 1e6) * INPUT_PER_MTOK +    (cached / 1e6) * CACHED_INPUT_PER_MTOK +    (output / 1e6) * OUTPUT_PER_MTOK  );} // Same 200k-token context, 5k output, called 1000 times a day:costUSD({ fresh: 200_000, cached: 0, output: 5_000 }) * 1000; // ≈ $2,250/daycostUSD({ fresh: 20_000, cached: 180_000, output: 5_000 }) * 1000; // ≈ $630/day

Entrada custa US$ 10 por milhão de tokens e saída custa US$ 50. Entrada em cache custa US$ 1. Ou seja, a coisa de maior alavancagem nesse patamar de preço não tem nada a ver com técnica de prompt: é estruturar as requisições para que a parte grande e estável do contexto fique no início e seja cacheada, e só a parte pequena e específica da tarefa seja nova.

import OpenAI from "openai"; const client = new OpenAI(); // The knobs that actually move the bill: reasoning effort and cache hits.const response = await client.responses.create({  model: "gpt-6-astra",  reasoning: { effort: "low" },      // low | medium | high | xhigh | max  input: [    // Keep the stable prefix first so prompt caching can hit it: $1/Mtok    // cached vs $10/Mtok fresh is a 10x difference on the same tokens.    { role: "system", content: SYSTEM_PROMPT },    { role: "user", content: userTask },  ],  tools: [{ type: "web_search" }],});

O controle de esforço de raciocínio merece a mesma disciplina. São cinco níveis, e o instinto de ir direto no max é como os times acabam com uma fatura que não conseguem explicar. A maior parte do tráfego em produção é classificação, extração e roteamento — trabalho que não se beneficia de raciocínio profundo e não deveria pagar por ele.

Para dar contexto: o GPT-5.6 Terra custa US$ 2 de entrada / US$ 12 de saída, e o Claude Opus 5 custa US$ 5 / US$ 25. O Astra a US$ 10 / US$ 50 não é uma opção um pouco mais cara, é outra faixa — e ainda existe um modo rápido, com cerca de 2,5x de velocidade por 2x do custo.

Isso significa que a pergunta interessante de engenharia no fim de 2026 não é "qual modelo é o melhor". É roteamento. O formato que continua funcionando é um modelo barato atendendo a cauda longa de chamadas simples, com um caminho de escalonamento para o modelo caro na fração pequena de requisições que realmente precisa de autonomia multi-etapa. Qualquer coisa diferente disso é pagar preço de fronteira para reformatar JSON.

Vale dizer com todas as letras: um modelo melhor em concluir tarefas sem supervisão também é um modelo capaz de gastar mais do seu dinheiro antes de alguém perceber que deu errado. Teto de tokens por tarefa e um alarme rígido de gasto não são otimização prematura aqui. São a mesma categoria de controle que um timeout em um cliente HTTP.

O Astra atinge o limiar "Crítico" no Preparedness Framework da OpenAI para cibersegurança. No lançamento, a capacidade disponível publicamente é revisão e correção segura de código; a criação avançada de exploits fica restrita a um programa fechado.

A metade defensiva é genuinamente útil e eu colocaria em um pipeline de CI amanhã — como revisor que abre apontamentos, nunca como algo com permissão de commit. Mas vale ler o que a restrição implica, não o que ela diz. Uma capacidade que precisa ser retida da disponibilidade geral é uma capacidade que existe. A postura defensiva que decorre disso não é pânico, é a mais entediante possível: assuma que o custo de encontrar uma vulnerabilidade no seu código está caindo mais rápido do que o custo de escrevê-la, e realoque orçamento de acordo.

Três coisas, na ordem do que mais se paga.

Instrumente antes de migrar. Se você não consegue quebrar seu gasto de tokens por funcionalidade e por ponto de chamada, uma mudança de 5x no preço é invisível até a fatura chegar. Isso é barato de construir e é pré-requisito para todas as outras decisões aqui.

Projete o caminho de escalonamento, não a escolha do modelo. Faça o modelo ser um parâmetro da chamada, não uma constante no seu código. Todo provedor que foi substituído estava, em algum momento, hardcoded na camada de serviço de alguém.

Dê fronteiras às execuções autônomas. Um shell hospedado e computer use são tão seguros quanto o sandbox em que você os coloca. Credenciais com escopo, teto de tokens por execução e trilha de auditoria do que o agente realmente fez. Nada disso é conselho novo; o modelo só tornou tudo isso estrutural.

O resumo honesto é que o Astra move a fronteira da autonomia e deixa a parte difícil exatamente onde estava. Decidir o que um sistema deve fazer, o que ele nunca pode fazer, e quem responde quando ele faz mesmo assim — isso continua sendo engenharia, e nenhuma pontuação de benchmark vem tomar esse lugar.