Agente com GPT-6 Sol parou no meio da tarefa: como retomar sem perder o que já foi feito

Fala aí, beleza? Cena clássica: você deixou o agente rodando uma refatoração grande, foi tomar um café, voltou e o terminal tá fechado

Ou estourou o contexto, ou a sessão encerrou, ou simplesmente deu timeout

E aí tem doze arquivos alterados no disco que você não escreveu, um teste quebrado que você não sabe se é dele ou seu, e zero ideia do que o bicho já tinha decidido

O problema aqui NÃO é o modelo

O problema é que o estado de uma tarefa agêntica vive fora do modelo: parte no disco (arquivos alterados), parte no transcript da sessão, parte na sua cabeça (as aprovações que você deu no meio do caminho)

O GPT-6 Sol foi lançado pela OpenAI em 22/09/2026 junto com o GPT-6 Luna, treinado com métodos parecidos aos do GPT-6 Astra, e a própria documentação da API posiciona ele para código complexo e fluxos agênticos, equilibrando inteligência e custo entre o Astra e o Luna

Ou seja: é modelo feito pra tarefa longa. E tarefa longa quebra no meio, é da vida

A boa notícia é que existe caminho oficial de retomada tanto no Codex CLI quanto na Responses API. Bora ver na prática?

O que você precisa antes de retomar

Antes de sair digitando "continue de onde parou", se liga no básico:

• Acesso ao modelo: no lançamento, GPT-6 Sol e GPT-6 Luna chegaram ao ChatGPT Work e ao Codex para usuários Plus, Pro, Business, Enterprise e Edu, e na API como gpt-6-sol e gpt-6-luna
• Atenção ao endpoint: pela documentação do GPT-6 Sol, a Responses API é a que suporta ferramentas nativas e function calling; no Chat Completions o suporte é parcial, só function calling com reasoning_effort definido como none
• Repositório versionado: sem git você não consegue separar o que o agente mexeu do que você mexeu. É o mínimo do mínimo
• Saber onde vive o transcript: o Codex grava os transcripts locais de sessão dentro de CODEX_HOME (por exemplo, ~/.codex). A flag --ephemeral evita persistir os arquivos de rollout da sessão em disco, então quem roda com ela não tem o que retomar depois
• Saber seu modo de persistência na API: objetos de resposta são guardados por 30 dias por padrão, e isso pode ser desligado com store=false. Objetos de Conversation e seus items não têm esse TTL de 30 dias

E tem o detalhe chato do rollout: a liberação no ChatGPT foi gradual ao longo do dia do lançamento, então quem não via o modelo devia tentar de novo mais tarde

Se o modelo não aparece, nem sempre é bug seu 🙂

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

Passo a passo: retomar sem refazer o que já foi feito

A regra de ouro é: congela primeiro, conversa depois

Todo prejuízo de retomada que eu vejo por aí nasce da mesma pressa, que é abrir sessão nova e mandar "termina isso" sem antes olhar o que já existe no disco

1. Congele o estado do disco antes de mandar qualquer coisa pro modelo

    git status --short
    git diff > /tmp/retomada.patch
    git diff --name-only

Isso te dá a lista exata de arquivos tocados e o conteúdo da mudança. É a tua fonte da verdade, não o que o agente disser depois

O erro comum deste passo: abrir a sessão nova primeiro e deixar o agente rodar ferramenta antes de você fotografar o disco. Aí você nunca mais sabe o que era dele e o que era novo

2. Escreva um arquivo de estado FORA do modelo

Um markdown simples na raiz do projeto, escrito por você, com fatos e não com desejos:

    # ESTADO-RETOMADA.md

    ## Já concluído (NÃO refazer)
    - src/auth/session.ts: migrado para o novo store, testes passando
    - src/auth/token.ts: renomeado validateJwt -> verifyAccessToken

    ## Chamadas de ferramenta já executadas
    - npm install jose (feito, lockfile commitado)
    - migração de banco 0012 (aplicada em dev)

    ## Decisões tomadas
    - manter compatibilidade com o header Authorization antigo por 2 releases

    ## Ficou pela metade
    - src/middleware/guard.ts: import atualizado, corpo da função ainda no formato antigo

    ## Próximo passo único
    - terminar guard.ts e rodar a suíte de auth

O erro comum deste passo: escrever o que você QUERIA que tivesse acontecido em vez do que aconteceu. O arquivo de estado é relatório, não plano

3. Retome a sessão original no Codex CLI

Existe comando pra isso, você não precisa reconstruir a conversa na mão:

    codex resume --last
    codex resume <session-id>
    codex resume --all

Pela referência do Codex CLI, codex resume reabre uma sessão anterior; com --last ele continua a mais recente do diretório atual e com --all considera sessões de qualquer diretório. O comando também aceita um prompt de continuação junto

E dentro de uma sessão já aberta, o slash command /resume abre o seletor de chats salvos do repositório atual e deixa você buscar chats locais mais antigos

A lógica é a mesma em outros agentes de terminal: quem já precisou retomar a sessão do Claude Code vai reconhecer o raciocínio na hora

O erro comum deste passo: rodar codex resume --last de outra pasta e achar que o CLI vai adivinhar o projeto. Sem --all, a busca é do diretório atual

4. Resolva o diretório certo antes de deixar o agente escrever

Se o diretório atual difere do diretório salvo na sessão, o Codex pergunta qual usar. Isso é ótimo, e é também onde muita gente responde no automático e quebra o projeto errado

A configuração tui.resume_cwd aceita current ou session, e existe o override explícito com a flag --cd

O erro comum deste passo: retomar uma sessão de outro repo dentro do repo aberto e deixar o agente aplicar patch no lugar errado. Tome cuidado aqui, os rm -rf da vida moram nessa esquina

5. Retomada não interativa (CI, script, pipeline)

No modo não interativo o fluxo é o mesmo, com subcomando:

    codex exec "review the change for race conditions"
    codex exec resume --last "fix the race conditions you found"

Cada execução retomada mantém o transcript original, o histórico de plano e as aprovações. Isso é exatamente o que você quer: o segundo comando não começa do zero, ele continua

O erro comum deste passo: rodar a primeira execução com --ephemeral e tentar resume depois. Sem rollout persistido em disco, não tem sessão pra reabrir

6. Se o que estourou foi o contexto, compacte em vez de reabrir do zero

Dentro do Codex CLI, /compact substitui os turnos anteriores por um resumo conciso, liberando contexto e mantendo os detalhes críticos

É mais barato e mais seguro que abrir sessão nova e recontar a história inteira na mão

O erro comum deste passo: compactar e depois assumir que cada linha da conversa antiga continua acessível. O que ficou foi o resumo, então o que é regra de verdade tem que estar em arquivo (próximo passo)

7. Fixe as regras que não podem se perder em AGENTS.md

Resumo some, arquivo não. O comando /init gera um AGENTS.md

    /init

E o detalhe que faz diferença: o Codex CLI enumera os arquivos AGENTS.md a partir de ~/.codex e de cada diretório da raiz do repositório até o diretório atual, mesclando na ordem (diretórios mais profundos sobrescrevem), e injeta cada arquivo como mensagem própria no topo do histórico

Traduzindo: o que está ali entra em TODA sessão, retomada ou não. É o lugar de colocar "nunca reescreva migrations já aplicadas" e "não mexa em pasta de build"

Se você monta agente pela API, o raciocínio de deixar fixo no system prompt é irmão gêmeo desse aqui

O erro comum deste passo: escrever no AGENTS.md o passo a passo da tarefa do dia. Ali vai o que é permanente, a tarefa vai no prompt

8. Monte o prompt de retomada

Prompt de retomada bom é curto, aponta pro estado congelado, proíbe o retrabalho e define UM próximo passo:

    Leia ESTADO-RETOMADA.md e rode `git status --short` antes de qualquer coisa

    NÃO refaça nada listado em "Já concluído"
    NÃO reinstale dependências nem reaplique migrações

    Próximo passo único: terminar src/middleware/guard.ts seguindo o padrão já aplicado em src/auth/session.ts

    Critério de parada: a suíte de auth passando. Pare e me mostre o diff antes de tocar em qualquer outro arquivo

O erro comum deste passo: pedir "continue" e mais três melhorias no mesmo prompt. Retomada é uma coisa só, depois você amplia

Retomando pela API: previous_response_id, replay e Conversations

Agora pra quem roda o agente em código próprio chamando gpt-6-sol na Responses API

São três formas oficiais de gerenciar estado de conversa: previous_response_id, replay manual dos itens anteriores como input, e a Conversations API com um objeto de conversa persistente

1. Escolha a forma de estado antes de escrever a lógica de retry

    resp = client.responses.create(
        model="gpt-6-sol",
        instructions=SYSTEM_PROMPT,
        input="continue do passo 3 do ESTADO-RETOMADA.md",
        previous_response_id=last_id,
    )

O erro comum deste passo: misturar os três modos no mesmo agente e não saber mais qual é a fonte da verdade quando a coisa quebra

2. Reenvie as instructions em todo request

previous_response_id encadeia o contexto da conversa, mas não carrega as instructions de topo da resposta anterior

Ou seja: instrução estável precisa ser reenviada a cada request, sempre

O erro comum deste passo: o clássico "o agente esqueceu as regras depois do terceiro turno". Não esqueceu, você parou de mandar 🙂

3. Saiba o seu prazo de validade

Objetos de resposta são guardados por 30 dias por padrão, e isso pode ser desligado com store=false. Objetos de Conversation e seus items não têm esse TTL de 30 dias

Pra agente de longa duração, Conversation resolve melhor a vida

O erro comum deste passo: guardar só o response_id num banco e descobrir meses depois que ele não encadeia mais nada

4. Com store=false, preserve TODOS os output items

Itens de reasoning voltam com a propriedade encrypted_content por padrão, o que permite replay stateless

Mas com store=false é você quem precisa preservar e reenviar todos os itens de output para manter o raciocínio entre turnos

    history.extend(resp.output)  # inclui os reasoning items com encrypted_content

    resp2 = client.responses.create(
        model="gpt-6-sol",
        instructions=SYSTEM_PROMPT,
        input=history + [{"role": "user", "content": "continue"}],
        store=False,
    )

O erro comum deste passo: guardar só o texto final da resposta e jogar fora os reasoning items. Aí o raciocínio "some" entre turnos e o agente volta a pensar do zero

5. Use compaction quando o transcript ficar gordo

Compaction reduz o contexto preservando o estado necessário para os próximos turnos. Dá pra ativar compaction server-side passando context_management com compact_threshold no request de criação, e nesse modo não é preciso chamar /responses/compact separadamente

O compact_threshold é o número de tokens que dispara a compactação, com mínimo de 1000

O erro comum deste passo: tratar o item de compactação como texto pra ler ou editar. Ele é opaco, não foi feito pra humano ler, e o jeito certo é reenviar ele como input no lugar do transcript completo

6. Calibre o esforço de raciocínio na retomada

O GPT-6 Sol aceita em reasoning.effort os níveis none, low, medium (padrão), high, xhigh e max

Retomada costuma ser trabalho de continuidade, não de descoberta. Nem toda retomada precisa de max

O erro comum deste passo: subir o effort pra resolver um problema que era de contexto perdido, e pagar mais por isso sem ganhar nada

Os travamentos mais comuns na retomada (e como prevenir)

Quando vale retomar e quando vale recomeçar

Nem toda sessão merece ser salva, beleza? Meu critério prático:

Vale retomar quando:

• A tarefa é longa, tem muitos arquivos tocados e você já deu aprovações no caminho. Refazer aprovação manual é o tipo de trabalho que ninguém quer repetir
• O que quebrou foi infraestrutura (terminal, rede, timeout) e não a direção da tarefa
• É pipeline não interativo em CI: codex exec resume --last "<novo prompt>" continua mantendo transcript, plano e aprovações
• É agente de longa duração via API, onde a Conversations API segura o estado sem o TTL de 30 dias das responses

Vale recomeçar limpo quando:

• O refactor saiu do trilho nos primeiros turnos. Retomar um plano ruim só faz você pagar duas vezes pelo mesmo erro
• A causa do problema era regra faltando: aí o certo é ajustar o AGENTS.md, dar git checkout no que sujou e começar de novo com o agente já sabendo o limite
• Você não consegue explicar em três linhas o que já foi feito. Se você não sabe, o modelo também não vai saber

E tem o lado financeiro, que ninguém gosta de olhar mas conta

No tier Standard, o GPT-6 Sol custa US$ 2,00 por 1M de tokens de entrada e US$ 10,00 por 1M de saída em contexto curto; em contexto longo, US$ 4,00 de entrada e US$ 15,00 de saída

Converte pelo dólar a R$ 5,10 do fechamento de 22/09/2026 e tu sente na hora o peso de reprocessar 1M de tokens à toa, ainda mais em contexto longo

Agora os modificadores, que é onde tá o jogo: input cacheado custa 10% da taxa de input não cacheado, Batch e Flex custam 50% do Standard, e Fast custa 2x a taxa aplicável

Ou seja, refazer do zero uma tarefa longa não é só perder tempo, é reprocessar contexto inteiro na taxa cheia

Retomar bem é otimização de custo antes de ser conforto 😀

Conclusão: transforme retomada em rotina, não em emergência

A ideia central é uma só: o estado da tarefa precisa viver fora do modelo

Git pro que está no disco, AGENTS.md pro que é regra permanente, arquivo de estado pro que já foi concluído e pro que ficou pela metade

Com isso montado, retomar vira um comando (codex resume --last, /resume, codex exec resume --last, ou previous_response_id na API) em vez de uma reescrita da história

Próximo passo acionável, pra fazer hoje mesmo num projeto pequeno:

1. Rodar /init no repositório e escrever no AGENTS.md as três regras que você mais repete pro agente
2. Definir o tui.resume_cwd conforme o teu fluxo, pra não cair na pergunta de diretório no meio do apuro
3. Começar uma tarefa, interromper de propósito e retomar com codex resume --last, só pra ver o ciclo funcionando antes de confiar nele numa tarefa de duas horas

E ajusta o reasoning.effort conforme o caso: none, low, medium (padrão), high, xhigh e max estão todos ali pra serem usados com critério, não pra ficar no talo sempre

A OpenAI afirma que o GPT-6 Sol comete cerca de metade dos erros do GPT-5.6 Sol nos testes internos dela, o que é ótimo, mas nenhum modelo adivinha o que aconteceu num terminal que você fechou 🙂

Testa o ciclo curto antes, faça o teste! Até o próximo post!