GPT-6 Astra: Manual Prático para Maximizar Codex, Agentes e Custos

Objetivo:

Aprender a distribuir Luna, Terra, Sol e Astra de forma inteligente para maximizar o desempenho, reduzir custos e manter os fluxos de trabalho dos agentes em execução por longos períodos.

O GPT-6 Astra da OpenAI, anunciado em 3 de setembro de 2026, representa um grande salto na capacidade dos agentes de realizar tarefas computacionais complexas que antes exigiam considerável intervenção humana.

Mas o verdadeiro desafio não é mais simplesmente perguntar "o Astra consegue fazer essa tarefa?".

A pergunta importante agora é:

Onde o Astra realmente agrega valor, como devemos alocar nossos recursos, como podemos manter os agentes trabalhando por mais tempo e como alcançar tudo isso com o menor custo possível?

Este artigo é direcionado principalmente para aqueles que usam Codex e agentes de programação regularmente, especialmente em ambientes de pré-produção.

Público-alvo

Este manual foi projetado para pessoas que:

• Usam agentes via Codex ou a API da OpenAI em ambientes de pré-produção.
• Desejam alternar entre Luna, Terra, Sol e Astra para reduzir os custos mensais de API ou infraestrutura.
• Desejam construir fluxos de trabalho de longa duração para: depuração exaustiva, grandes refatorações, utilização de ferramentas de computador, verificação matemática, testes automatizados e tarefas que exigem manter o contexto por um longo período.

0. Pré-requisitos

Implantação, Enterprise, Daybreak e Disponibilidade

Antes de tentar otimizar o Astra, você deve primeiro verificar se o modelo está realmente disponível para sua conta e ambiente.

Data do anúncio

3 de setembro de 2026 — anúncio oficial

OpenAI — GPT-6 Astra

Implantação

De acordo com os anúncios oficiais, o Trusted Access/Daybreak será um dos primeiros canais de implantação.

Os planos Plus, Pro, Business e Enterprise, bem como a API e a AWS, seriam implantados posteriormente.

Em ambientes corporativos, o administrador pode precisar ativar explicitamente o acesso.

Pontos importantes

• Enterprise: o administrador deve ativá-lo quando aplicável.
• Camada gratuita: o Astra não está planejado como um modelo gratuito.
• Créditos: usuários de planos pagos podem ter opções de crédito adicionais dependendo do produto.
• Segurança cibernética: alguns recursos avançados podem ser condicionados a caminhos de acesso específicos, como o Daybreak.
• ID do modelo de API: gpt-6-astra.

Preço Padrão da API

De acordo com as taxas indicadas neste documento:

• Entrada: $10 / milhão de tokens.
• Saída: $50 / milhão de tokens.

Existem diferentes taxas e condições para certos modos, contextos longos, cache e processamento prioritário.

Regra fundamental:

só porque o Astra não aparece na interface não significa necessariamente que o modelo não existe para sua organização. Primeiro, verifique a disponibilidade, as permissões e a implantação.

Enquanto verifica o acesso, a estratégia pode ser construída usando Sol como modelo base.

1. Onde o Astra se destaca e onde o Sol é suficiente?

O Astra é projetado como um modelo de alto nível para tarefas profissionais, especialmente aquelas relacionadas a:

• uso do computador,
• navegação,
• engenharia de software,
• agentes,
• ciência,
• matemática,
• tarefas complexas de ponta a ponta.

A documentação oficial posiciona os modelos de alto nível para os trabalhos de ponta a ponta mais difíceis.

A estratégia correta, no entanto, não é usar o Astra para absolutamente tudo.

A estratégia correta é:

Use o Astra apenas quando sua maior capacidade tiver um impacto real no resultado.

1.1. Onde a diferença realmente aparece?

As diferenças mais importantes tendem a aparecer em tarefas onde vários fatores se combinam:

• vários arquivos ou módulos,
• muitas etapas consecutivas,
• uso intensivo de ferramentas,
• interação com interfaces gráficas,
• problemas difíceis de reproduzir,
• raciocínio matemático,
• depuração prolongada,
• alto custo de cometer um erro,
• perda de contexto,
• necessidade de manter uma estratégia por muito tempo.

Em tarefas cotidianas e simples, a diferença pode ser muito menor.

Portanto, uma boa regra é:

Não pergunte qual modelo é "melhor". Pergunte qual modelo é mais barato para completar esta tarefa corretamente.

1.2. OSWorld, Mind2Web e a questão da velocidade

Benchmarks como OSWorld e Mind2Web são úteis para entender as diferenças entre os modelos, mas devem ser interpretados corretamente.

Nas simulações de latência do OSWorld 2.0 mencionadas na documentação oficial, o Astra alcançou maior utilização do processador do que o Sol e mostrou aproximadamente 47% menos tempo por tarefa na comparação indicada.

Por exemplo:

• Astra: aproximadamente 40 minutos.
• Sol: aproximadamente 75 minutos.

A pontuação indicada foi de aproximadamente:

• Astra: 72,6%
• Sol: 65,7%

Da mesma forma, a documentação indica que Astra + o novo harness do Codex pode ser aproximadamente 1,9× mais rápido do que a experiência atual do Sol em certos testes do Mind2Web.

Mas lembre-se de duas coisas

1. É um benchmark.

Um resultado de 1,9× no Mind2Web não significa que toda tarefa interna em uma empresa será 1,9× mais rápida.

2. Ele fornece um sinal útil.

Quanto mais uma tarefa depender de:

• telas,
• ferramentas,
• navegação,
• múltiplas ações,
• decisões intermediárias,

mais sentido faz avaliar uma combinação de modelo + sistema de agente, em vez de apenas comparar tokens por segundo.

1.3. Quando o Sol é suficiente?

Use Sol, Terra ou Luna primeiro quando:

• a resposta pode ser concluída em uma única troca;
• você só precisa modificar um ou dois arquivos;
• os testes são curtos;
• a tarefa é principalmente de leitura;
• nenhuma GUI é necessária;
• nenhuma ferramenta complexa é necessária;
• o custo de repetir o trabalho é baixo;
• uma falha não gera grandes consequências.

O Astra começa a fazer sentido quando ocorre o oposto

Por exemplo:

• muitos arquivos;
• vários módulos;
• longas cadeias de ferramentas;
• uso do computador;
• depuração complexa;
• verificação matemática;
• tarefas onde uma falha implica muito retrabalho;
• perda de contexto durante uma sessão longa.

2. ChatGPT, API e Configuração do Codex

2.1. ChatGPT: selecione Astra

Quando o Astra estiver disponível:

1. Abra o ChatGPT na Web ou Desktop.
2. Verifique o seletor de modelo.
3. Selecione Astra / GPT-6 Astra.
4. Se você usa o Codex, verifique se o mesmo modelo está disponível lá.
5. Se o Astra não aparecer: verifique o plano; verifique as permissões corporativas; verifique a implantação; use o Sol como configuração temporária.

Os planos Pro, Business e Enterprise podem incluir variantes específicas do Astra. Você não deve tirar conclusões apenas com base no nome exibido na interface: sempre revise a descrição correspondente ao plano.

2.2. API: model = "gpt-6-astra"

A configuração básica consiste em especificar o modelo na API Responses.

Considerações importantes

• Para chamadas de ferramentas, prefira usar a API Responses.
• O Astra não suporta reasoning.effort = "none".
• Se você usar um baixo nível de raciocínio, comece com uma configuração pequena e aumente apenas quando necessário.
• Alguns parâmetros tradicionais, como temperature ou top_p, podem não estar disponíveis.
• A residência de dados na UE pode impor restrições ao Fast/Priority.
• A configuração de cache pode ser migrada para prompt_cache_options.ttl.

2.3. Codex: gerenciamento experimental de contexto

Para sessões longas, o Codex pode usar mecanismos de gerenciamento de contexto que vão além da simples compressão do histórico.

A ideia é reter informações importantes, como:

• hipóteses investigadas;
• hipóteses descartadas;
• arquivos inspecionados;
• testes executados;
• resultados obtidos;
• decisões tomadas.

Uma configuração conceitual pode ser:

A configuração experimental de gerenciamento de contexto deve ser tratada como tal e verificada em relação à versão atual do Codex antes de ser adotada como padrão da equipe.

Por que isso importa?

Em uma sessão de depuração com várias horas de duração, perder o contexto pode forçar o agente a reinvestigar:

• quais hipóteses já foram descartadas;
• quais arquivos já foram revisados;
• quais comandos já funcionaram;
• quais testes já foram executados.

Fazer anotações reduz essa repetição.

Importante:

nunca armazene informações confidenciais, segredos, chaves de API ou dados sensíveis em notas persistentes do agente.

2.4. Aprovações e sandbox

O objetivo da automação não deve ser:

"Que o agente possa fazer absolutamente tudo."

O objetivo deve ser:

Automatizar tudo o que é reversível e manter a intervenção humana apenas em pontos irreversíveis ou de alto risco.

Configuração interativa recomendada como ponto de partida:

O agente pode cuidar de:

• ler arquivos;
• executar testes;
• analisar logs;
• fazer alterações locais;
• criar commits;
• preparar um Pull Request;
• revisar seu próprio trabalho;
• corrigir erros.

O humano deve manter o controle sobre:

• produção;
• implantações;
• merge final;
• publicação;
• envio de informações externas;
• modificação de permissões;
• operações irreversíveis;
• informações confidenciais.

A aprovação deve se tornar o último ponto de verificação, não uma interrupção constante ao longo do processo.

2.5. AGENTS.md e Skills

Antes de iniciar um trabalho importante com o Codex, o agente deve conhecer as regras do projeto.

Uma arquitetura útil é:

AGENTS.md

Contém:

• regras permanentes;
• escopo permitido;
• restrições;
• condições de conclusão;
• testes obrigatórios;
• pontos de aprovação humana.

Skills

Contêm:

• procedimentos repetitivos;
• fluxos de trabalho;
• listas de verificação operacionais;
• processos especializados.

MCP

Usado para:

• conexões externas;
• serviços;
• ferramentas;
• fontes de dados.

Uma divisão simples seria:

AGENTS.md = regras

Skills = procedimentos

MCP = conexões

Exemplo mínimo de AGENTS.md

3. Como escrever instruções que alavancam o Astra

A qualidade das instruções tem um enorme impacto em agentes de longa duração.

O Astra pode ser muito sensível a:

• ambiguidades;
• contradições;
• instruções obsoletas;
• Skills inconsistentes;
• regras duplicadas.

Portanto, uma boa configuração pode melhorar o desempenho tanto quanto a troca de modelos.

3.1. Aumente a autonomia

Em vez de criar instruções que fazem o agente pedir confirmação constantemente, defina claramente o espaço dentro do qual ele pode agir por conta própria.

3.2. Aprovação após resultados revisáveis

Uma das melhores regras para agentes autônomos é:

Primeiro produza um resultado revisável; depois peça aprovação para a etapa irreversível.

Isso evita o padrão:

agente → pergunta → humano → agente → pergunta → humano

e o substitui por:

agente → investiga → implementa → testa → prepara resultado → humano aprova → ação final

3.3. Perguntas que não bloqueiam a tarefa principal

Em sessões longas, pode ser útil permitir perguntas independentes sem interromper o fluxo principal.

Uma boa regra é:

A tarefa principal tem uma condição de conclusão fixa de uma frase. Se uma pergunta independente surgir durante a execução, responda-a brevemente sem interromper a tarefa principal. Só pare o fluxo de trabalho principal quando a pergunta mudar a direção da tarefa, o escopo, as permissões ou a saída necessária.

A API também pode usar mecanismos para enviar instruções adicionais durante uma execução e ferramentas assíncronas para trabalho prolongado.

3.4. Delegação para subagentes

Quando uma tarefa pode ser paralelizada, faça-o explicitamente.

Se a paralelização provavelmente reduzirá o tempo de execução ou melhorará a qualidade, delegue subtarefas independentes a outros agentes. Prefira trabalho paralelo para investigações independentes, alterações no nível do módulo, verificação de testes, verificações de documentação e revisão de código. Mantenha as mensagens entre agentes concisas, explícitas e legíveis.

Exemplos de paralelização:

• Agente A → investigar módulo de autenticação.
• Agente B → analisar testes.
• Agente C → revisar tipos.
• Agente D → revisar documentação.

Em seguida, o agente principal integra os resultados.

3.5. Controle o volume de testes

Mais testes nem sempre significam um resultado melhor.

Para pequenas alterações:

O objetivo é evitar que uma modificação trivial acione uma enorme bateria de testes desnecessários.

3.6. Modelo para depuração prolongada

3.7. Modelo para tarefas de computador e navegador

4. Maximize o valor, não a contagem de tokens

A pergunta certa não é:

"Como posso gastar todos os tokens do Astra?"

A pergunta certa é:

"Como posso obter mais trabalho concluído para cada dólar gasto?"

De acordo com as taxas indicadas:

O Astra é claramente mais caro por token.

Mas o preço por token não representa necessariamente o custo real de concluir uma tarefa.

Se o Astra alcançar:

• menos erros;
• menos iterações;
• menos retrabalho;
• menos chamadas de ferramentas;
• menor tempo total;
• maior taxa de sucesso;

então o custo por tarefa concluída pode ser competitivo ou até menor.

4.1. Tabela de roteamento prática

A regra geral:

Luna/Terra para volume → Sol para trabalho padrão → Astra para trabalhos que realmente justifiquem seu custo.

4.2. Hábitos que reduzem custos

1. Escreva a condição de conclusão primeiro

Isso reduz a exploração desnecessária.

1. Evite monólogos intermediários

Priorize:

Estado → Próxima ação → Resultado

em vez de explicações intermináveis.

1. Envie verificações simples para modelos econômicos

Não desperdice o Astra com:

• verificação de formato;
• resumo de logs pequenos;
• classificação de arquivos;
• realização de tarefas repetitivas.

1. Estabilize o prefixo da instrução

Manter as instruções do sistema/desenvolvedor consistentes pode favorecer o uso eficiente do cache.

1. Use modos rápidos apenas quando eles agregarem valor

Se um modo custa mais, ele deve ser justificado por uma redução real no tempo de execução.

4.3. Auditoria de custos semanal

A cada semana, revise:

• tarefas executadas com o Astra;
• motivo pelo qual foi usado;
• resultado;
• custo aproximado;
• se o Sol teria sido suficiente;
• se a Terra teria sido suficiente;
• número de iterações;
• falhas;
• retrabalho.

Regra simples

Se você não conseguir explicar por escrito:

"O Astra foi necessário porque..."

considere mover essa categoria de tarefas para um modelo inferior.

5. Fluxo de Trabalho Recomendado

5.1. Depuração longa

Etapa 1 — Classificação

Se houver vários arquivos, reprodução complexa ou muitas ferramentas:

Astra.

Se for simples:

Sol/Terra.

Etapa 2 — Limites

Defina em AGENTS.md:

• arquivos permitidos;
• arquivos proibidos;
• comandos permitidos;
• testes obrigatórios;
• pontos de aprovação.

Etapa 3 — Configuração

model = "gpt-6-astra" approval_policy = "on-request" sandbox_mode = "workspace-write" [features.context_management] experimental_mode = true

Etapa 4 — Início

Sempre comece com uma condição de conclusão clara.

Etapa 5 — Registro

Retenha:

• hipóteses;
• testes;
• resultados;
• arquivos examinados;
• decisões.

Etapa 6 — Interrupções

Perguntas independentes não devem destruir o contexto da tarefa principal.

Etapa 7 — Entregável

O agente pode ir até:

Pull Request pronto para revisão.

O merge final permanece sob controle humano.

Etapa 8 — Aprendizado

Se o mesmo problema aparecer repetidamente:

transforme-o em uma

Skill

.

5.2. Refatoração em larga escala

Uma estratégia de dois estágios funciona bem:

Estágio 1 — Investigação barata

Use:

Luna → Terra → Sol

para construir:

• mapa de dependências;
• impacto;
• módulos afetados;
• riscos;
• plano de execução.

Estágio 2 — Implementação

Use:

Astra

para os módulos que realmente exigem maior capacidade.

Estágio 3 — Paralelização

Subagentes para:

• testes;
• verificação de tipos;
• revisão;
• módulos independentes.

Estágio 4 — Revisão humana

O humano se concentra em:

• arquitetura;
• APIs públicas;
• compatibilidade;
• decisões irreversíveis.

5.3. Uso do computador

Para tarefas de navegador ou GUI:

1. Defina claramente a tela alvo.
2. Defina operações proibidas.
3. Use o Astra quando a tarefa for longa ou visualmente complexa.
4. Use o harness mais recente do Codex quando aplicável.
5. Registre estados e procedimentos.
6. Transforme o resultado em um entregável revisável.

O número 1,9× no Mind2Web deve ser interpretado apenas como um benchmark, não como uma garantia de desempenho interno.

5.4. Agente baseado em API

Configuração conceitual:

Model: gpt-6-astra API: Responses Reasoning: low → high when required Tools: enabled Long-running tools: asynchronous when appropriate Human gate: final irreversible action

Para ferramentas de longa duração:

Use a execução assíncrona de ferramentas quando o tempo de execução da ferramenta for longo o suficiente para que a execução síncrona de bloqueio reduza a taxa de transferência.

Se o nível de dificuldade mudar durante a execução:

Aumente o esforço de raciocínio apenas quando a tarefa se tornar genuinamente difícil. Retorne a um nível de raciocínio mais baixo para execução de rotina quando apropriado.

A ideia é reservar os recursos mais caros para os momentos que realmente precisam deles.

6. O que Fazer e o que Não Fazer

O que Fazer

• Reserve o Astra para tarefas onde ele faça uma diferença real.
• Revise inconsistências entre AGENTS.md e Skills.
• Mantenha as aprovações como o último ponto de verificação.
• Gere resultados revisáveis antes de solicitar autorização.
• Ative o gerenciamento de contexto para tarefas longas quando aplicável.
• Registre hipóteses, testes e resultados.
• Trate benchmarks como orientação, não como um KPI interno.
• Meça a taxa de sucesso e o tempo por tarefa.
• Verifique desde o início se uma tarefa requer o Daybreak.
• Mantenha informações confidenciais fora das notas persistentes.

O que Não Fazer

• Use o Astra para cada pequena pergunta.
• Interprete frases promocionais como especificações técnicas.
• Trate experiências individuais do X ou Reddit como documentação oficial.
• Declare implantação corporativa antes de o administrador ativá-la.
• Dê acesso automático a operações irreversíveis.
• Armazene segredos ou informações confidenciais em arquivos de contexto.
• Execute enormes baterias de testes para alterações triviais.
• Use benchmarks externos como substitutos para métricas internas.

7. Plano de Implementação de 60 Minutos

0–5 minutos

Verifique se o gpt-6-astra está disponível:

• seletor de modelo;
• API;
• Codex.

Se for Enterprise, verifique as permissões do administrador.

5–15 minutos

Verifique:

model = "gpt-6-astra" approval_policy = "on-request" sandbox_mode = "workspace-write"

E, para experimentos de contexto:

[features.context_management] experimental_mode = true

Reinicie o Codex, se necessário.

15–25 minutos

Atualize AGENTS.md:

• escopo;
• restrições;
• testes;
• condições de conclusão;
• pontos de aprovação.

25–35 minutos

Crie uma tabela de roteamento:

Luna → Terra → Sol → Astra

35–55 minutos

Execute uma tarefa real de depuração de escopo limitado com o Astra.

Use uma condição de conclusão explícita.

55–60 minutos

Registre:

• O Astra foi realmente necessário?
• O Sol teria sido suficiente?
• Quanto retrabalho ele evitou?
• Qual configuração funcionou?
• O que deve se tornar uma Skill?

Isso é suficiente.

Você não precisa testar todos os recursos disponíveis.

Distribuição + limites + sessões longas = a base para alavancar o Astra.

8. Padrões Práticos Recorrentes

1. Foguete de dois estágios

Modelo econômico → Astra

Primeiro:

• investigação;
• definição de escopo;
• análise.

Depois:

• implementação complexa;
• integração;
• verificação.

2. Condição de conclusão desde o início

Em agentes longos, escreva na primeira parte da instrução:

"A tarefa será concluída quando..."

Isso evita exploração sem rumo.

3. Contexto e anotações

Para trabalhos longos, retenha:

• hipóteses;
• resultados;
• decisões;
• testes;
• arquivos importantes.

Não confie exclusivamente na memória comprimida do agente.

4. A aprovação deve ser a última etapa

Não interrompa constantemente.

Melhor:

Investigar → implementar → testar → preparar resultado → revisar → aprovar → executar ação irreversível

5. Benchmarks como orientação

Mind2Web e OSWorld podem ajudá-lo a decidir o que testar.

Mas os KPIs reais devem ser internos:

• taxa de sucesso;
• tempo de execução;
• custo por tarefa;
• número de iterações;
• retrabalho;
• intervenção humana.

9. Erros Comuns

Antes de concluir:

"O Astra é fraco."

verifique primeiro, nesta ordem:

1. Visibilidade

O modelo está realmente disponível?

1. Estrutura

O Codex está atualizado e configurado corretamente?

1. Prompt

As instruções são claras?

1. AGENTS.md

Existem regras contraditórias?

1. Skills

Existem procedimentos antigos ou inconsistentes?

1. Roteamento

Você está usando o modelo certo para o trabalho?

Muitas vezes o problema não é a capacidade do modelo.

É o ambiente no qual o modelo está trabalhando.

10. Lista de Verificação de Implementação para Equipes

• Defina quem usará o Astra.
• Ative as permissões administrativas necessárias.
• Estabeleça um proprietário e um prazo.
• Crie uma tabela de roteamento Luna/Terra/Sol/Astra.
• Crie um AGENTS.md mínimo.
• Defina approval_policy.
• Defina sandbox_mode.
• Defina pontos de intervenção humana.
• Documente operações confidenciais.
• Estabeleça uma revisão de custos semanal.
• Registre quais tarefas realmente exigem o Astra.
• Converta erros repetitivos em Skills.

A prioridade deve ser reduzir os erros e o retrabalho da equipe, não simplesmente maximizar a velocidade de um agente individual.

11. Árvore de Decisão: Sol vs. Astra

Use esta sequência no início de uma tarefa:

1. Pode ser concluída em uma única troca?

Sim → Luna / Terra / Sol

Não → continue.

1. Precisa de GUI, ferramentas ou muitas etapas?

Sim → Astra

Não → continue.

1. O custo da falha é alto?

Sim → Astra

Não → Sol/Terra

1. A tarefa pode mudar de dificuldade durante a execução?

Sim → considere Astra + ajuste dinâmico de raciocínio.

1. O Astra ainda está indisponível?

Execute o mesmo fluxo de trabalho com o Sol.

Quando o Astra aparecer, mude apenas o modelo e mantenha a estrutura.

12. Migração da API para o Astra

A ordem recomendada é:

1. Altere o modelo

model = "gpt-6-astra"

1. Use a API Responses

Especialmente se houver chamadas de ferramentas.

1. Revise o raciocínio

O Astra não usa:

reasoning.effort = "none"

Comece com um nível baixo quando for suficiente.

1. Remova parâmetros desnecessários

Revise parâmetros como:

temperature top_p

se o modelo ou endpoint não os suportar mais.

1. Revise o cache

Migre para:

prompt_cache_options.ttl

quando aplicável.

1. Revise a residência de dados

Se você usar requisitos de infraestrutura ou residência na UE, verifique as restrições correspondentes.

1. Ajuste o raciocínio dinamicamente

Durante uma tarefa difícil:

Aumente o esforço de raciocínio quando a tarefa se tornar genuinamente difícil.

Durante operações de rotina:

Retorne a um nível de raciocínio mais baixo quando o raciocínio adicional não for mais útil.

1. Ferramentas longas

Considere a execução assíncrona quando o tempo da ferramenta justificar.

13. Configuração Mínima do Codex

Uma configuração inicial pode ser:

model = "gpt-6-astra" model_reasoning_effort = "high" approval_policy = "on-request" sandbox_mode = "workspace-write" [features.context_management] experimental_mode = true

E o repositório deve conter um AGENTS.md que defina:

AGENTS.md

Objetivo

• Manter as alterações mínimas.
• A conclusão exige que todos os testes obrigatórios sejam aprovados.

Escopo permitido

• src/
• tests/

Pontos de aprovação

• Implantação em produção
• Transmissão externa de dados
• Alterações de permissão
• Merge final

Comportamento operacional

• Trabalhar de forma autônoma dentro do escopo aprovado.
• Preferir ações reversíveis.
• Produzir resultados revisáveis antes de solicitar aprovação.
• Não fazer perguntas de confirmação desnecessárias.

Após modificar a configuração:

1. reinicie o Codex;
2. execute uma pequena tarefa de leitura;
3. verifique se o ambiente funciona;
4. inicie a tarefa principal.

14. Defina "utilização máxima" em uma única frase

Neste documento, utilização máxima não significa consumir o número máximo de tokens.

Significa:

Concentrar a Astra em tarefas onde ela pode realmente fazer a diferença, executar todo o resto de forma econômica e construir uma base sólida de instruções, limites, aprovações e gerenciamento de contexto que permita que tarefas longas sejam concluídas sem interrupções desnecessárias.

Várias decisões decorrem desta definição:

• É melhor atualizar a tabela de roteamento semanalmente do que trocar modelos arbitrariamente.
• É melhor realizar um teste de depuração real do que experimentar cada novo recurso.
• É melhor medir o sucesso e o tempo por tarefa do que perseguir benchmarks.
• Não devemos transformar frases promocionais em especificações internas.
• Se a Astra estiver indisponível, a Sol pode ser usada como substituta temporária.

15. Os Três Entregáveis Fundamentais

No final, todo este sistema deve produzir três elementos:

1. Tabela de alocação dinâmica

Define quando usar:

Luna / Terra / Sol / Astra

2. AGENTS.md

Define:

• regras;
• escopo;
• restrições;
• testes;
• condições de conclusão;
• pontos de verificação humanos.

3. Prompt operacional longo

Deve definir:

• função;
• objetivo;
• condições de conclusão;
• procedimento;
• limites;
• ferramentas;
• validação;
• formato de saída.

Estes três elementos são mais importantes do que memorizar todo o catálogo de recursos.

16. Cartão de Classificação para Copiar

Use este cartão no início de cada sessão importante:

O cartão não precisa ser perfeito.

Seu objetivo é criar um hábito de classificação.

Se você recomendar a Astra, mas a tarefa só precisa de respostas curtas, provavelmente está superdimensionando o modelo.

Se a Sol falhar repetidamente devido à perda de contexto ou à incapacidade de concluir uma longa cadeia de ações, provavelmente é hora de subir para a Astra.

17. Como Pensar Realmente sobre Preço

As taxas por milhão de tokens são apenas parte da equação.

Por exemplo:

Astra

• Entrada: $10
• Saída: $50

Sol

• Entrada: $4
• Saída: $20

A Astra custa mais.

Mas vamos imaginar:

Sol

$5 de tokens + 4 tentativas + 2 falhas + retrabalho humano = alto custo real

Astra

$12 de tokens + 1 tentativa + resultado correto = menor custo total por tarefa

Portanto, para tarefas curtas:

O preço por token importa muito.

Para tarefas longas:

O custo por tarefa concluída importa muito mais.

A métrica final deve ser:

Custo × taxa de sucesso × tempo × intervenção humana

e não apenas:

$/1M tokens

Conclusão

O objetivo da Astra não deve ser torná-la o modelo padrão para tudo.

O objetivo deve ser construir um sistema onde cada modelo faça o trabalho para o qual é mais eficiente.

Luna

Volume e tarefas simples.

Terra

Equilíbrio entre custo e capacidade.

Sol

Trabalho padrão e programação geral.

Astra

Tarefas complexas, longas, agentivas, GUI, matemática, depuração e trabalhos onde a falha é cara.

O padrão mais poderoso é:

Investigar barato → planejar → executar com a Astra quando necessário → verificar → preparar um resultado revisável → intervenção humana apenas no ponto de verificação final.

A verdadeira otimização não é usar a Astra mais.

É saber exatamente quando a Astra vale a pena.

E quanto mais complexos os agentes, mais importante é a infraestrutura ao redor deles: AGENTS.md, Skills, sandbox, aprovações, gerenciamento de contexto.