
A GPT-6.2 Sol API e a GPT-6.2 Astra API recebem a mesma requisição, devolvem o mesmo formato de resposta e compartilham os mesmos limites. O que as separa é o preço: gpt-6.2-astra custa quatro vezes mais que gpt-6.2-sol por token, na PoYo e na OpenAI. Este post mostra o que a OpenAI diz sobre cada modelo, as evidências que ela publica e um roteador que envia o tráfego para o GPT-6.2 Sol por padrão e só escala para o GPT-6.2 Astra quando isso compensa.
O que é igual e o que é diferente
| Item | gpt-6.2-sol | gpt-6.2-astra |
|---|---|---|
| Endpoints na PoYo | /v1/responses, /v1/chat/completions | Igual |
| Contexto / entrada máxima / saída máxima | 1,050,000 / 922,000 / 128,000 tokens | Igual |
| Entrada / saída | Texto e imagem na entrada, texto na saída | Igual |
| Chamada de ferramentas | Somente Responses | Igual |
| Esforço de raciocínio | none rejeitado; comece em medium | Igual |
| Data de corte do conhecimento | 1º de junho de 2026 | 18 de maio de 2026 |
| Entrada / saída na PoYo por 1M | $1.60 / $8.00 | $6.40 / $32.00 |
| Leitura / escrita de cache na PoYo por 1M | $0.08 / $2.00 | $0.32 / $8.00 |
| Entrada / saída na OpenAI por 1M | $2.00 / $10.00 | $8.00 / $40.00 |
Como o formato da requisição é idêntico, o roteamento muda um único campo: a string model. Todos os outros campos, definições de ferramentas e parsers continuam iguais.
Como a OpenAI posiciona os dois modelos da GPT-6.2 API
O texto da OpenAI é consistente em todas as suas páginas para desenvolvedores:
- Changelog da API: "Use o GPT-6.2 Astra para tarefas exigentes de raciocínio e programação, ou o GPT-6.2 Sol para programação e fluxos de agentes do dia a dia."
- Guia do GPT-6.2: use o GPT-6.2 Astra "para as tarefas mais exigentes" ou o GPT-6.2 Sol "para trabalho complexo a um custo menor".
- Guia do GPT-6.2, sobre estilo: "O GPT-6.2 Astra é, por padrão, mais conciso e direto do que os modelos anteriores."
Isso dá um padrão sensato: o Sol é o modelo do dia a dia, e o Astra é o caminho de escalonamento.
As evidências: o system card do GPT-6.2 da OpenAI
O system card do GPT-6.2 da OpenAI é a página oficial que conseguimos ler que traz o Astra e o Sol lado a lado. É um documento de avaliação de segurança, então os testes pendem para ciência, engenharia de ML e segurança:
| Avaliação | Astra | Sol | Diferença |
|---|---|---|---|
| GPQA Diamond, sem ferramentas (acurácia) | 97.0% | 96.0% | 1 ponto |
| OpenAI Epoch Capabilities Index | 170.1 | 168.8 | Dentro dos intervalos de confiança um do outro |
| MLE-Bench Revised (percentil médio de referência) | 96.06 | 91.38 | Astra à frente |
| Sandbox Bench (alvos resolvidos) | 36.4% | 25.0% | Astra bem à frente |
| ExploitBench Internal Port (taxa de execução de código) | 53.5% | 50.5% | Astra um pouco à frente |
| SEC-Bench Pro (reprodução de vulnerabilidades) | 86.75% | 88.34% | Sol um pouco à frente |
O system card informa esforço de raciocínio máximo para alguns resultados do Astra e não informa o esforço do Sol, então trate a tabela como direção, não como uma diferença precisa. O padrão ainda é útil. Nos testes de conhecimento e raciocínio, os dois ficam próximos. Nas tarefas agênticas longas e de várias etapas, Sandbox Bench e MLE-Bench, o Astra se distancia. Isso bate com o posicionamento da OpenAI e é o tipo de requisição que vale a pena escalar.
Quando o preço maior compensa
Por token, o Astra custa 4× o Sol. Para um roteador Sol-first com escalonamento, o custo esperado por tarefa é:
cost(Sol-first) = c_sol + p × c_astra
cost(Astra-only) = c_astra
Aqui, p é a fração de tarefas que falham no Sol e são executadas de novo no Astra. Se os dois modelos usam contagens de tokens parecidas em uma tarefa, c_astra ≈ 4 × c_sol, e o Sol-first é mais barato sempre que p < 0.75. Com a revisão de código de 150K de entrada / 12K de saída do Preço da GPT-6.2 API, o Sol custa $0.336 e o Astra $1.344 na PoYo. Com uma taxa de escalonamento de 20%, o Sol-first fica em média em 0.336 + 0.2 × 1.344 = $0.605 por revisão, 55% abaixo do Astra-only.
Dois casos quebram essa conta:
- Tarefas que falham no Sol na maior parte das vezes. Se
pé alto para um tipo de requisição, a tentativa no Sol é dinheiro jogado fora. Encaminhe esse tipo direto para o Astra. - Falhas que você não consegue detectar. O escalonamento só funciona quando o seu código consegue distinguir uma resposta ruim de uma boa: testes, um JSON schema, um linter, um validador. Se nada verifica a saída, escolha o modelo por tipo de requisição desde o início.
As contagens de tokens por tarefa também variam de modelo para modelo, e a OpenAI não publica um multiplicador. Registre usage.output_tokens dos dois modelos com os seus próprios prompts antes de decidir a divisão.
Tabela de roteamento para a GPT-6.2 API
Estes padrões seguem o posicionamento da OpenAI e as evidências acima. Ajuste-os com as suas próprias medições.
| Tipo de requisição | Modelo padrão | Escalar para o Astra quando |
|---|---|---|
| Chat, respostas de suporte, resumos | gpt-6.2-sol | Raramente; ajuste o prompt primeiro |
| Programação do dia a dia: correção de bugs, pequenas features, revisões | gpt-6.2-sol | Os testes falham depois da mudança |
| Loops de agentes com ferramentas | gpt-6.2-sol | A execução atinge o limite de turnos sem terminar |
| Grandes refatorações e migrações em vários arquivos | gpt-6.2-astra | — |
| Engenharia de ML e pipelines de pesquisa | gpt-6.2-astra | — |
| Entregas profissionais longas (relatórios, análises) | gpt-6.2-astra | — |
| Compreensão de imagens (capturas de tela, gráficos) | gpt-6.2-sol | A resposta deixa passar detalhes que você consegue verificar |
O esforço de raciocínio é um segundo controle. Antes de escalar, tente a mesma tarefa no Sol com um nível de esforço maior, já que ela continua no preço por token do Sol. As páginas dos modelos GPT-6.2 da OpenAI não listam os níveis aceitos além de rejeitar none, então teste um nível antes de usá-lo em produção.
Um roteador Sol-first com escalonamento
O roteador abaixo envia uma tarefa ao Sol, valida a resposta e a executa de novo no Astra se a validação falhar. Ele inicia uma requisição nova para o escalonamento em vez de encadear com previous_response_id. O guia do GPT-6.2 da OpenAI avisa que certas trocas de modelo podem fazer a Responses API descartar itens de raciocínio, o que "pode reduzir a qualidade das respostas e aumentar o uso de tokens".
import os
from openai import OpenAI
client = OpenAI(base_url="https://api.poyo.ai/v1", api_key=os.environ["POYO_API_KEY"])
def run(model: str, developer: str, task: str, effort: str = "medium"):
return client.responses.create(
model=model,
input=[
{"role": "developer", "content": developer},
{"role": "user", "content": task},
],
reasoning={"effort": effort},
max_output_tokens=16000,
store=False,
)
def solve(developer: str, task: str, validate) -> tuple[str, str]:
"""Try GPT-6.2 Sol first; escalate to GPT-6.2 Astra if validate() fails."""
for model in ("gpt-6.2-sol", "gpt-6.2-astra"):
resp = run(model, developer, task)
text = resp.output_text
print(model, resp.usage.input_tokens, resp.usage.output_tokens)
if resp.status == "completed" and validate(text):
return model, text
raise RuntimeError("Both models failed validation")
validate é a sua verificação: fazer o parse do JSON, aplicar o patch e rodar os testes, ou comparar com um schema. Registre qual modelo respondeu cada tarefa. Depois de uma semana, a taxa de escalonamento por tipo de requisição mostra quais tipos devem ir direto para o Astra.
Duas observações operacionais:
- Mantenha a mensagem developer idêntica nas duas chamadas. Não conte com a chamada ao Sol aquecendo um cache para o Astra. Orce a primeira chamada ao Astra pela tarifa cheia de entrada ou de escrita de cache; escalonamentos posteriores que compartilham o mesmo prefixo podem então lê-lo do cache.
- Não troque de modelo no meio de uma conversa. Escolha o modelo no início de uma tarefa, ou reinicie a tarefa no outro modelo com o contexto completo.
Perguntas frequentes
Qual é a diferença entre a GPT-6.2 Sol API e a GPT-6.2 Astra API?
Mesmos endpoints, campos de requisição, janela de contexto (1.05M) e saída máxima (128K). O Astra custa quatro vezes mais por token, e a OpenAI o posiciona para as tarefas mais exigentes, enquanto o Sol é para programação e fluxos de agentes do dia a dia.
A GPT-6.2 Sol API é boa o suficiente para programação?
A OpenAI posiciona o Sol para a programação do dia a dia. Use-o como padrão e escale para o Astra quando os seus testes falharem; a taxa de escalonamento mostra quais tarefas precisam do Astra.
Quanto a GPT-6.2 Astra API custa a mais que o Sol?
Quatro vezes mais por token em todos os medidores. Na PoYo: $6.40 contra $1.60 de entrada e $32 contra $8 de saída por 1M de tokens.
Posso alternar entre o GPT-6.2 Sol e o Astra na mesma conversa?
Pode, mas a OpenAI avisa que trocas de modelo podem fazer a Responses API descartar itens de raciocínio. Reinicie a tarefa no outro modelo em vez de encadear com previous_response_id.
O GPT-6.2 Sol e o Astra usam o mesmo formato de requisição na API?
Sim. Mude apenas o campo model entre gpt-6.2-sol e gpt-6.2-astra. Veja o guia da GPT-6.2 API para os corpos de requisição completos.