📊 Ler o medidor antes de precisar dele
O Codex mostra o consumo por janela: uma de curto prazo e outra semanal, com data de reinício. Numa sessão de trabalho pesado, a semanal caiu cerca de 25 pontos em quarenta minutos. A leitura útil não é o número absoluto: é a taxa. Percentual consumido dividido pelo tempo de trabalho dá quantas horas de trabalho pesado ainda cabem na semana.
Copie e rode
Estimativa rápida de autonomia a partir de duas leituras do medidor
# anote dois pares (percentual restante, minutos de trabalho pesado) no mesmo dia
# exemplo: 90% às 0 min, 75% aos 40 min
# taxa = (90 - 75) / 40 = 0,375 pontos por minuto
# autonomia restante = 75 / 0,375 = 200 minutos de trabalho pesado
python3 -c "
p0, m0 = 90, 0
p1, m1 = 75, 40
taxa = (p0 - p1) / (m1 - m0)
print(f'taxa: {taxa:.2f} pontos/min')
print(f'restam ~{p1/taxa:.0f} min de trabalho pesado')
"📊 O que puxa a cota para baixo
- •Computer use: cada passo carrega uma captura de tela para o modelo. É o mais caro por minuto.
- •Esforço de raciocínio alto: mais tokens de raciocínio na mesma tarefa.
- •Tarefas longas com MCP: dezenas de chamadas e retornos no mesmo contexto.
- •Contexto grande: repositório inteiro lido a cada sessão nova em vez de reconhecimento salvo.
💡 Meça no seu pior dia, não no melhor
A taxa de consumo de um dia de leitura e texto engana. Calcule com um dia de computer use e MCP: é esse número que decide se a semana chega ao fim.
🎚️ Escolher o esforço certo para cada tarefa
Esforço alto ajuda quando o gargalo é raciocínio: um bug que atravessa módulos, uma migração com ordem de operações, uma decisão de arquitetura. Não ajuda quando o gargalo é contexto: se o agente não sabe onde está o arquivo, pensar mais não resolve, ler resolve.
| Tarefa | Esforço | Por quê |
|---|---|---|
| Trocar valor de configuração | low/medium | Achar e editar; raciocínio não é o gargalo |
| Refatorar CSS com critérios | medium | Muitas edições simples, critérios explícitos |
| Gerar vídeo com skill | medium | O procedimento está escrito na skill |
| Bug intermitente entre módulos | high | Hipóteses concorrentes, precisa raciocinar |
| Migração de dados com ordem | high | Erro custa caro, ordem importa |
| Reconhecimento de repo novo | medium | Leitura, não dedução |
✓ Sinais de que high vale a pena
- ✓O agente propôs duas soluções e escolheu a pior
- ✓A falha se repete com o mesmo raciocínio errado
- ✓A tarefa exige ordem correta de operações
- ✓Erro custa caro e é difícil de reverter
✗ Sinais de que high é desperdício
- ✗O agente não achou o arquivo (falta contexto, não raciocínio)
- ✗O procedimento já está escrito numa skill
- ✗A tarefa é repetição de um padrão conhecido
- ✗Você só quer "garantir", sem sintoma nenhum
Copie e rode
Rodar a mesma tarefa em dois níveis e comparar custo e resultado
# medium (padrão do config)
codex exec --skip-git-repo-check "<TAREFA>" > /tmp/saida-medium.txt
# high só nesta chamada
codex exec --skip-git-repo-check -c model_reasoning_effort="high" "<TAREFA>" > /tmp/saida-high.txt
diff /tmp/saida-medium.txt /tmp/saida-high.txt | head -40🪜 Orquestração: o caro planeja, o barato executa
O padrão: o modelo forte lê o problema e produz um plano detalhado, com passos, critérios e comandos. Esse plano vira um arquivo. Um modelo mais barato (local ou API econômica) executa passo a passo, e o forte só volta para revisar o resultado ou destravar. O forte aparece duas vezes; o barato, vinte.
Copie e rode
Passo 1: pedir ao modelo forte um plano executável por um modelo mais fraco
Produza um plano de execução para: <OBJETIVO>.
O plano será executado por um modelo mais fraco, que não tem o seu contexto. Portanto:
- cada passo deve ser autocontido (caminhos completos, comandos exatos);
- cada passo tem um critério de aceite verificável por comando;
- nenhum passo pode exigir julgamento estético ou decisão de arquitetura: essas decisões você toma agora e escreve como regra;
- liste no fim os pontos em que o executor deve parar e me chamar.
Salve em ./PLANO.md. Não execute nada.Copie e rode
Passo 2: executar o plano com um modelo mais barato, um passo por vez
# exemplo com modelo local via CLI (ajuste ao seu provedor)
codex exec --oss -m <MODELO_LOCAL> --skip-git-repo-check \
"Leia ./PLANO.md. Execute APENAS o passo <N>. Ao terminar, rode o critério de aceite do passo e cole a saída. Não avance para o próximo passo."
# revisão final volta ao modelo forte
codex exec -m gpt-6-astra --skip-git-repo-check \
"Revise o resultado da execução de ./PLANO.md: git diff --stat, e diga quais critérios de aceite não foram cumpridos."💡 O plano é o produto
Se o plano está bom, o executor barato funciona. Se o executor erra sempre no mesmo passo, o defeito está no plano, não no modelo. Corrija o arquivo.
🤖 Ligar o Astra aos seus agentes sem chave de API
Um agente local configurado para usar o provedor do Codex aproveita a sessão autenticada da assinatura. O ganho é direto: modelo de fronteira nos seus agentes sem chave separada. O custo é que tudo passa a consumir a mesma cota: sessões do Codex, seus agentes e qualquer automação.
✓ Bom uso da cota compartilhada
- ✓Um agente pessoal que você usa sozinho
- ✓Automações pontuais, sob demanda
- ✓Planejamento e revisão (poucas chamadas caras)
- ✓Prototipar antes de decidir se vale API
✗ Mau uso
- ✗Serviço com muitos usuários simultâneos
- ✗Laço automático sem teto de chamadas
- ✗Executor de volume (isso é trabalho do modelo barato)
- ✗Produção com necessidade de disponibilidade garantida
⚠️ Automação sem teto zera a cota dormindo
Antes de ligar qualquer laço automático ao provedor da assinatura, coloque um teto: número máximo de chamadas por execução e por dia. Um laço com erro roda a noite inteira.
Copie e rode
Teto simples para um laço automático que chama o agente
MAX=20
for i in $(seq 1 $MAX); do
codex exec --skip-git-repo-check "<TAREFA_DO_ITEM $i>" || break
done
echo "encerrado após no máximo $MAX chamadas"⏱️ Reduzir custo sem reduzir trabalho
Os cinco ajustes, em ordem de impacto
Salve o reconhecimento do repositório
maior economia isolada
O mapa do projeto (módulo 1.4) vai para um arquivo no repo. Sessões novas leem o arquivo em vez de reler o código inteiro.
Feche o escopo em toda tarefa
evita trabalho não pedido
A lista de arquivos permitidos impede o agente de "aproveitar e arrumar" outras coisas, que custa tokens e revisão.
Computer use só onde não há alternativa
o mais caro por minuto
Se existe comando, API ou MCP, use. Captura de tela a cada passo é o item mais caro do curso.
Vire ferramenta o que se repete
custo único contra recorrente
Terceira repetição da mesma tarefa: peça uma linha de comando e rode com modelo barato daí em diante.
Esforço medium por padrão
ajuste fino
high só quando a falha é de raciocínio. Anote no AGENTS.md quais famílias de tarefa precisam.
Copie e rode
Salvar o reconhecimento do repositório para reaproveitar em toda sessão
Escreva ./MAPA.md com o reconhecimento deste repositório:
- stack e comandos (subir, testar, build), exatos;
- estrutura de pastas com uma linha por pasta relevante;
- onde ficam configurações sensíveis (modelo, credenciais, endpoints) com arquivo:linha;
- os 5 arquivos mais arriscados e por quê;
- decisões de arquitetura que não são óbvias pelo código.
Depois adicione ao AGENTS.md a linha: "Leia MAPA.md antes de qualquer tarefa neste repositório."🧪 Prática: medir, planejar, orquestrar
Roteiro (40 min)
Escolha uma tarefa repetitiva real
Algo com dez ou mais passos parecidos: renomear em vários arquivos, gerar variações, aplicar um padrão.
Meça o baseline
Anote o percentual da cota, rode tudo no modelo forte, anote de novo. Guarde o resultado.
Rollback
git checkout para voltar ao estado inicial.
Plano
Peça o PLANO.md ao modelo forte. Leia e corrija os passos vagos.
Execução barata
Rode os passos com o modelo mais barato que você tem, um por vez.
Compare
Consumo de cota e qualidade do resultado, lado a lado. Decida qual família de tarefa vira orquestrada.
Copie e rode
Comparar os dois resultados de forma objetiva
# guarde os dois estados em branches
git checkout -b baseline-forte && git add -A && git commit -m "tudo no modelo forte"
git checkout main && git checkout -- .
# ...depois da execução orquestrada:
git checkout -b orquestrado && git add -A && git commit -m "plano + executor barato"
git diff baseline-forte orquestrado --stat🧪 Teste rápido do módulo
Três perguntas. Clique numa opção para ver a resposta.
1. Qual atividade consome mais cota por minuto?
2. Quando subir o esforço de raciocínio para high?
3. No padrão de orquestração, o modelo de fronteira aparece:
📋 Resumo do módulo
Próximo módulo:
2.4 - Memória compartilhada e o sistema completo