Como testar o GPT-6 Astra em tarefa de agente: o que observar além da resposta final

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

E aí todo mundo correu pra fazer a mesma coisa: mandar uma tarefa, esperar, ler a resposta final e dar veredito

Só que em tarefa de agente a resposta final é a parte MENOS informativa do teste

Agente não responde, ele roda

Ele escolhe ferramenta, executa, olha o retorno, decide de novo, e faz isso quantas vezes achar necessário

Duas execuções podem terminar com o mesmo texto bonito no final, sendo que uma resolveu em três voltas e a outra ficou quinze minutos reescrevendo o mesmo arquivo em círculo

Então a régua muda: pra testar o GPT-6 Astra em tarefa que roda sozinha, você precisa olhar o caminho, não o destino

O que você precisa antes de começar o teste

Três coisas, e nenhuma delas é opcional

1. Acesso ao modelo

O identificador na API da OpenAI é gpt-6-astra, e ele também está disponível via Microsoft Azure e Amazon Bedrock

Tome cuidado com uma coisa aqui: o rollout começou faseado em 3 de setembro de 2026, restrito a um conjunto limitado de organizações, com liberação gradual pra ChatGPT Plus, Pro, Business e Enterprise além da API

O lançamento foi confuso mesmo, com muita gente assinante ficando sem acesso imediato, e a empresa foi ampliando o acesso aos poucos

Ou seja: se você abriu e não achou, não é bug seu

2. Um ambiente que te deixe ver o meio da execução

Tem três caminhos razoáveis: o Codex CLI, o Agents SDK (que já vem com tracing ligado por padrão) ou a Responses API direto

Se você estava pensando na Assistants API, esquece: ela foi encerrada em 26 de agosto de 2026, e a Responses API é o caminho atual pra construir agente na OpenAI

Formação Recomendada

Formação Claude Code

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

• 114 aulas
• 4 projetos
• 9h 18min

Conhecer formação

3. Noção de custo, antes de rodar e não depois

Agente queima token de um jeito que chat não queima, porque cada volta reenvia contexto

E se liga nisso, que é a pegadinha do teste longo: acima de 272 mil tokens de entrada, a requisição INTEIRA passa a 2x nas taxas de input e cache e 1,5x no output

Não é só o excedente, é a requisição toda

Como testar o GPT-6 Astra em tarefa de agente, passo a passo

Bora ver na prática?

1. Defina a tarefa de várias etapas e o critério de sucesso ANTES de rodar

Escreva numa linha o que conta como "deu certo": o teste passa, o arquivo existe com tal conteúdo, o relatório cita tal fonte

Se o critério só nasce depois que você leu a saída, você não testou o modelo, você racionalizou o resultado dele

O erro comum deste passo: tarefa vaga tipo "melhore o projeto", que nenhuma execução consegue falhar nem passar

2. Ligue o registro de eventos

No modo não interativo do Codex, a flag --json transforma o stdout num stream JSON Lines com os eventos emitidos durante a execução, um por mudança de estado

codex exec --json "refatore o módulo de autenticação e rode os testes" > execucao.jsonl

Depois você lê o arquivo com calma, no seu ritmo, em vez de tentar acompanhar texto passando na tela

O erro comum deste passo: rodar sem redirecionar, perder o stream e ficar só com a última tela do terminal

3. Use o tracing do Agents SDK e abra a execução no painel

O tracing vem habilitado por padrão e registra gerações do modelo, chamadas de ferramenta, handoffs e guardrails

Cada execução vira um Trace e cada chamada de modelo, ferramenta, guardrail ou handoff vira um Span

Dá pra inspecionar tudo no dashboard em platform.openai.com/traces

Ler o Trace de cima pra baixo é o mais próximo que você chega de ver o agente pensando

O erro comum deste passo: desligar o tracing "pra não poluir" e ficar cego justamente na parte que interessa

4. Abra cada chamada de ferramenta pelo span dela

O function_span registra os argumentos de entrada, o valor de retorno e a latência da chamada

É daí que sai a resposta pras perguntas que realmente importam: qual arquivo foi tocado, qual comando foi executado, o que voltou

Quando a mesma ferramenta aparece com argumentos quase idênticos várias vezes seguidas, você já tem o diagnóstico na mão

O erro comum deste passo: olhar só a latência total e ignorar o conteúdo do retorno, que é onde mora o motivo do retrabalho

5. Conte as voltas do laço e trave o limite

O Runner.run aceita o parâmetro max_turns, e ao estourar o limite é lançada a exceção MaxTurnsExceeded

try:
    result = await Runner.run(
        agente,
        "refatore o módulo de autenticação e rode os testes",
        max_turns=12,
    )
except MaxTurnsExceeded:
    print("estourou o limite de voltas, hora de olhar o trace")

Esse número não é chute pra sempre: rode uma vez com folga, veja quantas voltas a tarefa realmente pede, e aperte depois

O erro comum deste passo: deixar sem limite nenhum e descobrir o problema pela fatura

6. Acompanhe o raciocínio em streaming

A Responses API emite eventos específicos pro resumo de raciocínio do modelo

response.reasoning_summary_text.delta   (trecho parcial)
response.reasoning_summary_text.done    (texto completo do resumo)

O .delta te dá o acompanhamento ao vivo, o .done te dá o bloco fechado pra guardar junto do resto do log

O erro comum deste passo: tratar o resumo de raciocínio como prova do que aconteceu, quando a prova mesmo é a chamada de ferramenta

7. Repita a mesma tarefa

Uma execução é anedota

Rode a mesma tarefa duas ou três vezes e compare caminho com caminho: mesmas ferramentas? mesma ordem? mesmo número de voltas?

A própria OpenAI divulgou comparação separando tarefa resolvida em uma única tentativa de tarefa resolvida em até quatro, o que já diz bastante sobre a importância de repetir

O erro comum deste passo: mudar o prompt entre as rodadas e achar que ainda está medindo consistência

8. Anote tokens e custo da rodada

Fecha a planilha: tokens de entrada, tokens de saída, quanto entrou em cache, e se a rodada cruzou os 272 mil tokens de entrada (porque aí a faixa de preço muda pra requisição inteira)

O erro comum deste passo: comparar duas execuções pelo tempo de relógio, ignorando que uma delas custou várias vezes mais

Agente em loop: como reconhecer e interromper cedo

Agente travado não avisa que travou

Ele continua parecendo ocupado, e é aí que a conta cresce

Sintomas que aparecem no meio da execução:

• o mesmo arquivo aparecendo tocado repetidas vezes nos spans de ferramenta
• o mesmo comando executado de novo, com argumentos quase iguais
• as voltas subindo no log de eventos sem nenhuma mudança de estado real
• retorno de ferramenta idêntico voltando várias vezes seguidas

Causa provável: a tarefa não tem critério de parada explícito, então o modelo fica tentando "melhorar" algo que já estava pronto, ou insiste num caminho que devolve o mesmo erro

O corte, no Codex CLI:

• Esc interrompe a tarefa em execução, sem encerrar a sessão
• Ctrl+C ou o comando /exit fecham a sessão, o que é uma ação diferente (cuidado pra não confundir as duas na pressa)
• Esc duas vezes com o campo de texto vazio edita a mensagem anterior e cria um fork do chat, ou seja, você volta pro ponto onde deu ruim e tenta outro caminho sem perder tudo

Esse fork é a jogada mais subestimada do teste: em vez de recomeçar do zero, você bifurca exatamente na volta em que o agente entrou no buraco

O Codex CLI ainda tem comandos de barra pra dirigir a sessão em andamento, como /model, /fast, /personality, /permissions, /approve, /raw, /agent e /status

Prevenção, e aqui muda o escopo: o critério de parada você escreve dentro da própria tarefa, em qualquer ambiente

Já o max_turns é parâmetro do Runner.run do Agents SDK (aquele do passo 5), não uma opção do Codex CLI, então ele entra quando o seu teste roda pelo SDK

Duas linhas de configuração que valem mais que qualquer detector esperto

Três tarefas de agente que revelam coisas diferentes

Uma tarefa só não testa o modelo, testa um humor dele

1. Tarefa de código multi-arquivo

Peça algo que obrigue a mexer em três ou quatro arquivos relacionados e rodar os testes no fim

O que isso expõe: quantos arquivos foram tocados de verdade, quanto de retrabalho apareceu (arquivo editado, desfeito e editado de novo) e se o agente rodou o teste antes ou depois de declarar vitória

2. Tarefa de uso de computador

A OpenAI reporta 72,6% no OSWorld 2.0, número divulgado pela própria empresa no anúncio, então trate como o que é: um dado do fabricante, não um veredito independente

Esse tipo de tarefa expõe outra coisa, que é a recuperação depois do erro: clicou no lugar errado, e aí?

Se você ainda está decidindo que tipo de trabalho faz sentido delegar assim, vale entender o uso de computador no GPT-6 Astra antes de montar o roteiro

3. Tarefa longa de pesquisa ou documento

Essa é a que estressa contexto: 1.050.000 tokens de contexto e até 128.000 tokens de saída

É também a que faz a conta virar de faixa, porque passar de 272 mil tokens de entrada joga a requisição inteira pra 2x no input e no cache e 1,5x no output

E quando a entrega é grande, o teto de saída começa a pesar: vale planejar o fatiamento sabendo do limite de 128 mil tokens de saída em vez de descobrir com o texto cortado no meio

Falando em número da própria empresa, a comparação que a OpenAI divulgou entre Astra e o GPT-5.6 Sol foi essa:

Repare no que a segunda linha conta: a diferença entre uma tentativa e quatro é exatamente o assunto deste post

O caminho importa

O que aprendi observando agentes rodarem sozinhos

Não testei o Astra pra escrever isso, e não vou fingir que testei

Mas eu já montei agente do zero e gravei o processo, e foi ali que caiu a ficha sobre olhar o meio da execução

No vídeo abaixo eu mostro a criação de um agente de IA no n8n, e começo justamente separando workflow de agente, porque vejo MUITA gente confundindo os dois no início

Workflow tem começo, meio e fim, roda da esquerda pra direita, mesmo quando tem bifurcação ou uso de LLM no meio

No agente é diferente: as ferramentas ocupam o lugar dos passos, e ele decide sozinho quais usar e em qual ordem, podendo repetir a mesma ferramenta várias vezes

É por isso que muita gente troca agente por workflow depois de um tempo: cria o agente achando que é melhor pra situação, e só com o uso percebe que um workflow resolvia

A parte que mais transfere pro teste do Astra é a tela de debug

O chat de teste fica dividido: à esquerda as mensagens trocadas, à direita a área que exibe as ações e as etapas que o agente executou pra chegar na resposta

No começo você nem olha pra direita

Depois, quando o agente passa a fazer mais coisas entre uma etapa e outra, é só pra lá que você olha

Teve um momento no vídeo que resume tudo: eu digo meu nome, o agente responde usando meu nome, e logo em seguida pergunto qual é o meu nome, e ele responde que não sabe porque a informação não foi passada

A resposta final estava impecável nas duas vezes

O caminho é que estava quebrado (faltava memória)

Agente que faz operação em sequência ou várias interações com o usuário PRECISA manter contexto: pensa num agente de WhatsApp tentando vender um produto sem conseguir segurar o fio da conversa 😅

Outras coisas que ficaram comigo dali e valem pra qualquer teste:

• comece pelos modelos mini nos testes, gasta menos na conta da OpenAI
• se o resultado já sai bom com um modelo mais fraco, com um melhor tende a ficar melhor ainda, desde que tudo esteja bem configurado (não dá pra ter certeza absoluta, depende da configuração estar bem feita)
• extraia o máximo das ferramentas simples antes de complicar: memória simples salva na própria ferramenta resolve boa parte dos agentes, e é bem mais fácil que partir direto pra nó de memória com banco de dados
• documentação é a melhor referência quando você está fazendo algo novo, e o próprio painel costuma te oferecer o link das docs na hora de criar a credencial
• salve manualmente, senão o trabalho se perde (já me ferrei com isso)

O nó de agente sozinho não faz nada até receber o chat model, que é a única configuração obrigatória

Muda a ferramenta, muda o modelo, mas a lição é a mesma: o agente só ganha utilidade quando você monta o conjunto e olha o painel de execução pra entender as etapas, em vez de julgar pelo texto que aparece no fim

O próximo passo: monte seu roteiro de teste antes de rodar

O veredito vem do caminho, beleza?

Quantos arquivos foram tocados, quais comandos rodaram, quantas voltas o laço deu, quanto disso foi retrabalho

O texto final é só a última linha do log

Próximo passo concreto, e dá pra fazer hoje: escolhe UMA tarefa de várias etapas, escreve o critério de sucesso, define o max_turns se o teste for pelo Agents SDK, liga o log de eventos e roda duas vezes

Compara os dois caminhos, não as duas respostas

Duas ressalvas pra fechar

Custo: Batch e Flex saem a 50% das taxas Standard, então bateria de teste que não precisa de resposta na hora não tem motivo pra rodar no Standard

E cuidado redobrado com o escopo do que você entrega pro agente: o GPT-6 Astra é o primeiro modelo da OpenAI classificado no nível Critical de capacidade em cibersegurança do Preparedness Framework, ou seja, com ferramentas e acesso adequados ele pode encontrar falhas desconhecidas e desenvolver formas de explorá-las sem orientação humana passo a passo

Não é motivo pra pânico, é motivo pra pensar duas vezes em quais permissões e quais credenciais ficam ao alcance da sessão de teste

Monta o roteiro, roda, e volta no log 😀

até o próximo post!