# Como deixar Claude Code e Codex a trabalhar durante a noite com /goal em 2026 > O comando /goal no Claude Code 2.1.139 e no Codex CLI executa um agente de IA autonomamente durante horas. Explico a configuração, exemplos reais e quantos tokens custa. Source: https://ailoot.ai/blog/pt-pt/goal-mode-claude-code-codex/ Canonical: https://ailoot.ai/blog/pt-pt/goal-mode-claude-code-codex/ Language: pt-PT Publisher: Ailoot (https://ailoot.ai/) Translation: guide-103 Revision: sha256-d8850970087dba7a7ca527fb748cbc90ba6d7395ba81301ca9e704e2907cc004
Principais conclusões O comando `/goal` surgiu no Claude Code 2.1.139 (11 de maio de 2026) e no Codex CLI 0.128.0 (30 de abril de 2026, estável desde 21 de maio). Define-se uma vez o critério de conclusão, e o agente percorre autonomamente um ciclo de planeamento, ação e verificação até cumprir o critério ou ficar sem tokens. A OpenAI apresentou publicamente uma execução de 25 horas que utilizou 13 milhões de tokens. É uma solução adequada para migrações, benchmarks e refatorações com critérios mensuráveis. Não é adequada para tarefas de interface, bases de dados de produção ou pedidos vagos como «torna-o melhor».
Pode encontrar informações sobre como trabalhar com Ailoot na [documentação](https://ailoot.ai/docs/). ## O que é o `/goal` e porque surgiu em 2026?
Principais conclusões Antes do `/goal`, cada turno do agente exigia uma instrução manual para «continuar». O agente abria um ficheiro, lia-o, escrevia alguma coisa, parava e esperava. O comando `/goal` define uma única vez um critério de conclusão: o agente decide por si próprio quando a tarefa está concluída e não devolve o controlo até terminar.
O cenário que todos conhecíamos antes de abril de 2026: dou uma tarefa ao Claude — «migra o projeto de Pydantic v1 para v2». Começa, para após 30 segundos, vejo o que fez, escrevo «continua», dá o passo seguinte, para e eu volto a escrever «continua». Numa migração de grandes dimensões, isso significa 200–300 instruções manuais para continuar, e acabo a tomar conta do agente em vez de escrever outro código em paralelo. A análise da OpenAI concluiu que o problema não era a «estupidez» do modelo, mas a arquitetura do ciclo. O modelo não sabia quando devia parar, por isso travava em cada turno. Se lhe dermos um critério de conclusão, ele decide por si próprio. Foi assim que surgiu o `/goal` — um mecanismo integrado no harness, não no modelo. A observação foi feita na conferência Code with Claude, em Londres, nos dias 19 e 20 de maio de 2026. Descreve o que aconteceu durante o mês seguinte ao lançamento do `/goal` nas duas ferramentas. ## Como configurar o modo Goal no Claude Code?
Principais conclusões O Claude Code 2.1.139 foi lançado a 11 de maio de 2026 com o comando `/goal`. Um modelo pequeno (Haiku, por predefinição) verifica o critério após cada turno. Se o critério não estiver cumprido, o Claude inicia outro turno. O critério pode ter até 4 000 caracteres e só pode existir um objetivo por sessão.
Um exemplo mínimo da documentação oficial da Anthropic: ```bash claude -p "/goal CHANGELOG.md has an entry for every PR merged this week" ``` Este comando inicia o agente em segundo plano com um objetivo. O Claude encontra os PR, compara-os com o CHANGELOG.md, acrescenta as linhas em falta e para quando o critério estiver cumprido. No modo interativo, basta escrever `/goal` seguido da condição: ``` /goal all pytest tests pass and mypy strict reports zero errors ``` O que o Claude faz a seguir: - Após cada turno, um modelo rápido separado (Haiku, por predefinição) recebe a condição atual e o histórico da conversa - Este modelo responde «sim» ou «não», com uma justificação breve - Se a resposta for «não», o Claude inicia automaticamente outro turno sem lhe devolver o controlo - Se a resposta for «sim», o objetivo é limpo e o controlo volta para si

Após cada turno, um modelo pequeno e rápido verifica se a condição foi cumprida. Se não tiver sido, o Claude inicia outro turno sem lhe devolver o controlo.

— Documentação oficial do Claude Code, https://code.claude.com/docs/en/goal
Limites rigorosos de que só se apercebe quando os encontra: - O `/goal` só funciona em diretórios de trabalho para os quais aceitou o diálogo de confiança. Se estiver num computador novo e o Claude ainda não tiver memorizado esse diretório, o comando falhará - Em ambientes empresariais com `disableAllHooks` ou `allowManagedHooksOnly`, o comando não está disponível - A condição pode ter até 4 000 caracteres - Só pode haver um objetivo ativo por sessão. Um novo `/goal` repõe o anterior - Com `--resume`, a condição é preservada, mas os contadores de turnos, tempo e tokens são repostos Comandos de controlo: - `/goal` sem argumento — mostra o estado atual - `/goal clear` (ou `stop`, `off`, `reset`, `none`, `cancel`) — limpa o objetivo Segundo a Anthropic, o custo do avaliador é «normalmente insignificante em comparação com o custo do turno principal». O Haiku avalia o critério e o texto da conversa sem recorrer a ferramentas, pelo que a verificação é barata; a parte dispendiosa são os turnos do modelo principal. ## Como configurar o `/goal` no Codex CLI?
Principais conclusões O Codex CLI 0.128.0 acrescentou o `/goal` a 30 de abril de 2026 como funcionalidade experimental. A 21 de maio, o modo tornou-se estável na versão 26.519 / npm 0.133.0. Funciona através de dois modelos de prompt — `continuation.md` («continuar») e `budget_limit.md` («parar»). O objetivo está associado à thread e mantém-se após reinícios.
O comando é igual ao do Claude: ```bash codex > /goal all vitest tests pass and there are no eslint errors ``` O Codex oferece mais controlos de objetivos: | Comando | O que faz | |-----------------|---------------------------| | `/goal condition` | define um objetivo | | `/goal` | mostra o estado | | `/goal pause` | pausa | | `/goal resume` | retoma | | `/goal edit` | altera a condição (com GA) | | `/goal clear` | limpa o objetivo | A principal diferença em relação ao Claude é que o próprio Codex verifica se está «concluído», em vez de recorrer a um modelo separado. Após cada turno, o Codex insere automaticamente no contexto o modelo `continuation.md` do repositório `openai/codex`. Uma tradução literal: > «Continua a trabalhar para alcançar o objetivo ativo da thread. Não repitas trabalho já concluído. Escolhe a próxima ação concreta para avançar em direção ao objetivo. Só assinala o objetivo como alcançado quando uma auditoria demonstrar que foi efetivamente cumprido e que não resta trabalho necessário.» Quando os tokens se aproximam do limite, é inserido um segundo modelo — `budget_limit.md`: > «O objetivo atingiu o limite de tokens. Não comeces trabalho substancial novo. Termina este turno o mais depressa possível: resume o progresso útil, identifica o trabalho restante e os bloqueios e deixa ao utilizador um próximo passo claro.» A lógica é a mesma: «não mintas sobre o que fizeste». Só se deve continuar se o objetivo ainda não tiver sido realmente cumprido. Ao atingir o limite, é preciso parar e descrever com honestidade o que falta. Ao contrário do Claude, o Codex associa o objetivo à thread, não à sessão. Por exemplo, pode fechar o terminal à noite e abri-lo de novo de manhã, e o `/goal resume` retoma o mesmo objetivo com os mesmos factos em memória. Isto é útil para execuções divididas em etapas segundo o seu próprio horário. ## Em que difere o `/goal` no Claude Code do `/goal` no Codex?
Principais conclusões O Claude separa o autor do avaliador: o modelo principal escreve código e um modelo pequeno separado avalia-o. O Codex é um único agente que verifica o próprio trabalho — lembra-se: «não mintas sobre o que fizeste». As arquiteturas diferem, mas o risco de entrar num ciclo é o mesmo.
Esta é a diferença mais frequentemente ignorada nas comparações, por isso vamos analisá-la em pormenor. | Aspeto | Claude Code `/goal` | Codex `/goal` | |----|----|----| | Lançamento | v2.1.139, 11 de maio de 2026 | v0.128.0, 30 de abril de 2026 (experimental) → v0.133.0 / 26.519, 21 de maio de 2026 (estável) | | Âmbito do objetivo | Sessão | Thread (mantém-se após reinícios) | | Controlos | `set`, `clear` (+ aliases) | `set`, `view`, `pause`, `resume`, `edit`, `clear` | | Quem verifica se está «concluído» | Modelo separado (Haiku, por predefinição) | O próprio agente, através de um prompt inserido | | Acesso do avaliador aos ficheiros | Não; avalia apenas o texto da conversa | Sim; pode inspecionar ficheiros, testes e registos | | Orçamento | No texto da condição: «ou para após 20 turnos» | Limite de tokens integrado + inserção automática de `budget_limit.md` | | Limite máximo de despesa | Nenhum; apenas o limite da subscrição | Nenhum; apenas o limite da subscrição | | Comprimento da condição | Até 4 000 caracteres | Não especificado | | Onde funciona | Modo interativo, `-p`, aplicação de ambiente de trabalho, Remote Control | Aplicação, extensão de IDE, CLI, clientes ACP | A diferença conceptual é que o Claude trata o ciclo como um contrato de qualidade (um avaliador externo), enquanto o Codex o trata como um mecanismo de execução (o agente gere-se a si próprio). Na prática, isto significa que, se quiser um critério de conclusão imparcial, deve escolher o Claude. Se quiser que o agente possa verificar ficheiros e registos durante a avaliação, escolha o Codex. Saiba mais sobre as ferramentas no [guia Codex vs Claude Code](https://ailoot.ai/blog/pt-pt/codex-vs-claude-code-choice/). ## Exemplo real: migração de Pydantic v1 para v2 em 31 horas
Principais conclusões O Codex `/goal` concluiu a migração de um serviço interno com 14 000 linhas de Pydantic v1 para v2 em 31 horas de tempo real, distribuídas por quatro sessões. O custo foi de aproximadamente $44 com o gpt-5.3-codex.
A tarefa foi definida da seguinte forma: «migra de Pydantic v1 para v2, todos os testes pytest têm de passar e o mypy strict tem de indicar zero erros». O que aconteceu: - Sessão 1 (8 horas) — o Codex analisou os imports, reescreveu as declarações `BaseModel` e configurou o mypy - Sessão 2 (10 horas) — reescreveu os validadores e fez falhar cerca de 200 testes - Sessão 3 (7 horas) — corrigiu os testes e encontrou dependências circulares - Sessão 4 (6 horas) — resolveu os erros de mypy e as regressões restantes Custo dos tokens: > «Tempo total no relógio: cerca de 31 horas em quatro sessões. Custo total dos tokens do Codex às tarifas do gpt-5.3-codex: cerca de \$44.» O custo deve-se sobretudo aos tokens de saída do gpt-5.3-codex, à tarifa de \$14 por milhão. Isto significa que 31 horas de trabalho autónomo custam aproximadamente o mesmo que várias semanas de subscrição do ChatGPT Plus. O que o agente não fez por iniciativa própria: - Não escreveu documentação da migração para a equipa (o Codex não percebeu que isso fazia parte da «migração») - Não atualizou os ficheiros de configuração para publicar com a nova versão de Pydantic - Não detetou uma regressão de produção, que só foi identificada no dia seguinte Por outras palavras, o `/goal` fez 95% do trabalho; os restantes 5% continuam a ter de ser feitos manualmente. Isso é normal na geração atual e não é motivo para deixar de o utilizar. ## 14 horas durante a noite num controlador para macOS
Principais conclusões ## Que tarefas se adequam a longas execuções noturnas Os controladores, enquanto categoria de tarefas, não se adequam bem ao trabalho interativo, mas são ideais para ciclos de longa duração.
Os tipos de tarefas em que esta abordagem oferece os maiores ganhos: - Trabalho de baixo nível em que uma iteração e uma verificação demoram minutos (compilação, execução de testes) - Migrações com critérios formais claros (tipos, testes, lint) - Benchmarks e otimizações com resultados mensuráveis - Documentação e changelogs com uma estrutura clara O Claude `/goal` faz o mesmo igualmente bem, mas o Codex é escolhido com maior frequência para controladores porque verifica ficheiros e registos por si próprio, em vez de depender de um avaliador externo. ## Quanto custa e como evitar gastar todos os tokens durante a noite?
Principais conclusões O `/goal` não tem um limite máximo rígido de despesa — apenas os limites do seu plano. Uma hora real de trabalho do Codex custa cerca de $1.50–$3 com o gpt-5.3-codex. O Claude custa mais a executar e menos a avaliar. A única proteção consiste em escrever «ou para após N turnos» na própria condição.
Números de relatos públicos: | Execução | Duração | Tokens | Custo | |----|----|----|----| | Demonstração da ferramenta de design da OpenAI | 25 horas | 13M | (execução interna) | | Pydantic v1→v2 | 31 horas, 4 sessões | ~3,1M de saída | ~\$44 | | Sistema de entrevistas por voz | 6 horas e 44 minutos no total (41 minutos de computação) | 6,8 milhões de entrada, 94% em cache | \- | | Teste rápido de fontes | 5 minutos | 188 832 | menos de 5% da quota semanal | O essencial é perceber o seguinte: nem o Claude Code nem o Codex oferece um limite rígido para «parar de gastar ao chegar a $N». Há três medidas de proteção: 1. **Limites da subscrição** — Pro, Max ou Enterprise. No plano Max da Anthropic ($100 por mês), uma execução noturna de 14 horas cabe na quota semanal e ainda sobra margem 2. **Limite de texto na condição** — escreva diretamente no `/goal`: «ou para após 20 turnos». O avaliador do Claude lê esta condição e encerra o objetivo 3. **Limite de tokens no Codex** — mecanismo integrado que insere `budget_limit.md` quando os tokens se esgotam O que aumenta a fatura durante a noite: - Um critério vago como «torna-o mais conveniente» — o agente nunca vai parar, porque o avaliador não sabe o que significa «melhor» - Acesso a APIs externas sem stubs — cada nova tentativa custa tokens - Contexto longo — após 6.7M tokens, inicia-se a compactação do contexto e perde-se alguma memória Saiba mais sobre como poupar custos nos guias [para onde vão os tokens do Claude Code](https://ailoot.ai/blog/pt-pt/where-claude-code-tokens-go/) e [como não esgotar os seus limites](https://ailoot.ai/blog/pt-pt/claude-code-token-limits-saving/). ## Quando NÃO executar o `/goal`: 5 situações
Principais conclusões Critérios vagos como «faz com que tenha bom aspeto», alterações de uma linha, bases de dados de produção com dados de utilizadores, alterações críticas de segurança e tarefas com dependências externas pouco claras. Em qualquer uma destas cinco situações, o agente ficará preso num ciclo ou gastará tokens sem motivo.
A documentação da OpenAI diz explicitamente o que NÃO fazer: 1. **Alterações de uma linha** — executar o `/goal` para mudar o nome de uma variável custa mais do que fazê-lo manualmente 2. **Objetivos vagos** — «melhora o desempenho», «torna o código mais limpo», «torna-o mais conveniente». O avaliador não dispõe de critérios, por isso o agente ficará num ciclo sem fim 3. **Bases de dados de produção com dados de utilizadores** — o agente pode estragar uma migração, e restaurar uma cópia de segurança custa mais do que qualquer poupança 4. **Alterações de segurança** — autenticação, encriptação, processamento de pagamentos. Uma pessoa tem de rever cada commit neste caso 5. **APIs externas sem stubs** — cada falha de rede custa tokens e está fora do seu controlo Os fluxos de segurança exigem aprovação manual, e dependências externas pouco claras podem interromper uma execução a meio. ## O que fazer se o agente ficar preso?
Principais conclusões Um sinal de que o agente entrou num ciclo é editar o mesmo ponto durante 3–4 turnos e depois reverter as alterações. Interrompa-o com Ctrl+C, consulte o registo e, em seguida, torne o critério mais rigoroso ou reduza a tarefa a uma parte. No Claude, o `/goal clear` pode ajudar; no Codex, use `/goal pause` e edite a condição.
Como detetar rapidamente um ciclo: - O agente altera os mesmos ficheiros durante 3 ou mais turnos e repõe-nos no estado anterior - Surgem repetidamente no registo erros aos quais já respondeu - A condição parece-lhe cumprida, mas o agente indica «não cumprida» - O consumo de tokens por turno está a aumentar, mas não há progresso no código O que fazer a seguir: - No Claude Code: `/goal clear` e, em seguida, torne a condição mais específica - No Codex: `/goal pause`, inspecione a thread atual, edite a condição com `/goal edit` e depois use `/goal resume` - Em ambos: confirme que o critério pode realmente ser verificado (um comando devolve o código de saída 0 ou produz um resultado específico) Muitas vezes, a causa do ciclo é a própria tarefa, não o agente. A condição «todos os testes passam» pressupõe que os testes podem passar. Se existir um problema arquitetónico profundo no código, o agente continuará a dar voltas em torno do sintoma. ## Critérios de conclusão: disciplina na definição de tarefas para o `/goal`
Principais conclusões Um bom critério é um comando que devolve o código de saída 0 ou um resultado específico. «Todos os testes passaram» funciona. «O código está mais limpo» não. O melhor é combinar uma verificação formal com uma métrica mensurável — por exemplo, testes e cobertura mínima.
A OpenAI enuncia esta regra claramente no seu Codex Cookbook oficial:

Um objetivo não é considerado concluído só porque o modelo acha que está. Só está concluído quando o resultado tiver sido verificado com ficheiros, testes, registos, benchmarks ou outros elementos concretos.

— OpenAI Codex Cookbook, Utilizar Goals no Codex, https://developers.openai.com/cookbook/examples/codex/using_goals_in_codex
Modelos de critérios que funcionam na prática: | Tipo de critério | Como o formular | |----|----| | Testes | “pytest tests/ returns exit 0 and coverage is at least 80%” | | Tipos | “mypy strict reports zero errors on src/” | | Lint | “eslint . returns exit 0 on all changed files” | | Build | “npm run build completes successfully, with no TypeScript errors” | | Benchmark | “k6 run perf test shows p95 below 200 ms” | | Diff | “git diff shows changes only in files X, Y, Z” | | Combinação | “pytest is green AND mypy strict reports zero errors AND ruff check passes” | A combinação usada no exemplo inclui testes, mypy e lint. Se uma única verificação continuar a falhar, o objetivo não é encerrado. O avaliador não tem como fazer batota. Exemplos a evitar: - «O código está melhor» - «A facilidade de utilização melhorou» - «O desempenho melhorou» - «A documentação está completa» A diferença entre «funciona» e «não funciona» está na possibilidade de verificação. Se não for possível verificar um critério com um comando, não é possível verificá-lo de todo. É também a isto que a OpenAI chama «coerência de longo horizonte»: um agente pode pensar durante muito tempo, mas não consegue decidir por si próprio o que é «suficientemente bom». Pode experimentar a ideia de «um prompt — um resultado» num projeto real: defina o `/goal`, formule um critério, execute-o e analise o que correu mal.
### Fontes - [Documentação do Claude Code `/goal` (Anthropic)](https://code.claude.com/docs/en/goal) - [Changelog do Claude Code (Anthropic)](https://code.claude.com/docs/en/changelog) - [Changelog do OpenAI Codex](https://developers.openai.com/codex/changelog) - [OpenAI Codex Cookbook: Utilizar Goals](https://developers.openai.com/cookbook/examples/codex/using_goals_in_codex) - [Blog da OpenAI: executar tarefas de longa duração com o Codex (23 de fevereiro de 2026)](https://developers.openai.com/blog/run-long-horizon-tasks-with-codex) - [GitHub openai/codex: continuation.md](https://github.com/openai/codex/blob/6014b6679ffbd92eeddffa3ad7b4402be6a7fefe/codex-rs/core/templates/goals/continuation.md) - [GitHub openai/codex: budget_limit.md](https://github.com/openai/codex/blob/6014b6679ffbd92eeddffa3ad7b4402be6a7fefe/codex-rs/core/templates/goals/budget_limit.md)
Conheça o [Ailoot](https://ailoot.ai/). ## Perguntas frequentes ### O que torna útil um critério de conclusão de /goal? Use um resultado verificável: identifique o teste, verificação de tipos, compilação ou benchmark e o resultado exigido. Combine explicitamente as verificações e o âmbito de ficheiros permitido; «melhora isto» não dá um ponto de paragem mensurável. ### O que faço se o agente repetir as mesmas edições falhadas? Interrompa a execução e examine o registo. Se continuar a alterar e reverter os mesmos ficheiros, reduza a tarefa ou especifique melhor o critério; confirme que as verificações exigidas podem efetivamente passar antes de retomar. ## Ailoot · A empresa e a sua carteira de projetos A Ailoot assenta numa experiência operacional consolidada, numa ampla base de clientes, num serviço estável e no acompanhamento contínuo dos KPI. A empresa e a sua carteira de projetos: milhões de clientes; vendas mensais na ordem dos milhares de milhões. A Ailoot aplica essa experiência operacional ao acesso por API a funcionalidades de IA nos produtos dos clientes, agentes, aplicações e automatizações.