comparisons

GPT-6.2 Sol API vs GPT-6.2 Astra API: que pedidos encaminhar para cada um

Poyo.ai Team
9 min read
Share:

Encaminhamento entre a GPT-6.2 Sol API e a GPT-6.2 Astra API

A GPT-6.2 Sol API e a GPT-6.2 Astra API aceitam o mesmo pedido, devolvem a mesma estrutura de resposta e partilham os mesmos limites. O que as separa é o preço: gpt-6.2-astra custa quatro vezes mais do que gpt-6.2-sol por token, no PoYo e na OpenAI. Este artigo apresenta o que a OpenAI diz sobre cada modelo, as evidências que publica e um router que envia o tráfego para o GPT-6.2 Sol por predefinição e só escala para o GPT-6.2 Astra quando compensa.

O que é igual e o que é diferente

Itemgpt-6.2-solgpt-6.2-astra
Endpoints no PoYo/v1/responses, /v1/chat/completionsIgual
Contexto / entrada máxima / saída máxima1,050,000 / 922,000 / 128,000 tokensIgual
Entrada / saídaTexto e imagem na entrada, texto na saídaIgual
Chamadas de ferramentasSó ResponsesIgual
Esforço de raciocínionone rejeitado; começa em mediumIgual
Data de corte do conhecimento1 de junho de 202618 de maio de 2026
Entrada / saída no PoYo por 1M$1.60 / $8.00$6.40 / $32.00
Leitura / escrita de cache no 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 a estrutura do pedido é idêntica, o encaminhamento resume-se a mudar um campo: a string model. Todos os outros campos, definições de ferramentas e parsers ficam iguais.

Como a OpenAI posiciona os dois modelos da GPT-6.2 API

A formulação da OpenAI é consistente em todas as suas páginas para programadores:

  • Changelog da API: "Usa o GPT-6.2 Astra para tarefas exigentes de raciocínio e programação, ou o GPT-6.2 Sol para a programação do dia a dia e fluxos de trabalho de agentes."
  • Guia do GPT-6.2: usa o GPT-6.2 Astra "para as tarefas mais exigentes" ou o GPT-6.2 Sol "para trabalho complexo a um custo mais baixo."
  • Guia do GPT-6.2, sobre o estilo: "Por predefinição, o GPT-6.2 Astra é mais conciso e direto do que os modelos anteriores."

Isso dá uma predefinição sensata: o Sol é o modelo do dia a dia e o Astra é o caminho de escalada.

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 consultar que apresenta o Astra e o Sol lado a lado. É um documento de avaliação de segurança, por isso os testes inclinam-se para ciência, engenharia de ML e segurança:

AvaliaçãoAstraSolDiferença
GPQA Diamond, sem ferramentas (precisão)97.0%96.0%1 ponto
OpenAI Epoch Capabilities Index170.1168.8Dentro dos intervalos de confiança de ambos
MLE-Bench Revised (percentil de referência médio)96.0691.38Astra à frente
Sandbox Bench (alvos resolvidos)36.4%25.0%Astra claramente à frente
ExploitBench Internal Port (taxa de execução de código)53.5%50.5%Astra ligeiramente à frente
SEC-Bench Pro (reprodução de vulnerabilidades)86.75%88.34%Sol ligeiramente à frente

O system card indica o esforço de raciocínio máximo para alguns resultados do Astra e não indica o esforço do Sol, por isso trata a tabela como uma orientação e não como uma diferença precisa. Ainda assim, o padrão é útil. Nos testes de conhecimento e raciocínio, os dois estão próximos. Nas tarefas agênticas longas e com vários passos, Sandbox Bench e MLE-Bench, o Astra destaca-se. Isso coincide com o posicionamento da OpenAI e é o tipo de pedido que vale a pena escalar.

Quando é que o preço mais alto compensa

Por token, o Astra custa 4× o Sol. Para um router que começa pelo Sol e escala, 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 voltam a ser executadas no Astra. Se os dois modelos usarem contagens de tokens semelhantes numa tarefa, c_astra ≈ 4 × c_sol, e começar pelo Sol sai mais barato sempre que p < 0.75. Com a revisão de código de 150K de entrada / 12K de saída de preços da GPT-6.2 API, o Sol custa $0.336 e o Astra $1.344 no PoYo. Com uma taxa de escalada de 20%, começar pelo Sol dá uma média de 0.336 + 0.2 × 1.344 = $0.605 por revisão, 55% abaixo de usar só o Astra.

Há dois casos que estragam essas contas:

  • Tarefas que falham no Sol na maioria das vezes. Se p for alto para um tipo de pedido, a tentativa no Sol é dinheiro deitado fora. Encaminha esse tipo diretamente para o Astra.
  • Falhas que não consegues detetar. A escalada só funciona quando o teu código consegue distinguir uma resposta má de uma boa: testes, um JSON schema, um linter, um validador. Se nada verificar a saída, escolhe o modelo por tipo de pedido à partida.

As contagens de tokens por tarefa também variam de modelo para modelo, e a OpenAI não publica nenhum multiplicador. Regista usage.output_tokens dos dois modelos com os teus próprios prompts antes de decidires a divisão.

Tabela de encaminhamento para a GPT-6.2 API

Estas predefinições seguem o posicionamento da OpenAI e as evidências acima. Ajusta-as com as tuas próprias medições.

Tipo de pedidoModelo predefinidoEscalar para o Astra quando
Chat, respostas de suporte, resumosgpt-6.2-solRaramente; afina primeiro o prompt
Programação do dia a dia: correção de bugs, funcionalidades pequenas, revisõesgpt-6.2-solOs testes falham depois da alteração
Ciclos de agentes com ferramentasgpt-6.2-solA execução atinge o limite de turnos sem terminar
Grandes refatorações e migrações em vários ficheirosgpt-6.2-astra—
Pipelines de engenharia de ML e de investigaçãogpt-6.2-astra—
Entregáveis profissionais longos (relatórios, análises)gpt-6.2-astra—
Compreensão de imagens (capturas de ecrã, gráficos)gpt-6.2-solA resposta falha detalhes que consegues verificar

O esforço de raciocínio é um segundo controlo. Antes de escalar, experimenta a mesma tarefa no Sol com um nível de esforço mais alto, já que se mantém ao preço por token do Sol. As páginas dos modelos GPT-6.2 da OpenAI não listam os níveis aceites, além de rejeitarem none, por isso testa um nível antes de o usares em produção.

Um router que começa pelo Sol e escala

O router abaixo envia uma tarefa para o Sol, valida a resposta e volta a executá-la no Astra se a validação falhar. Para a escalada, inicia um pedido novo em vez de encadear com previous_response_id. O guia do GPT-6.2 da OpenAI avisa que certas mudanças de modelo podem fazer a API Responses descartar itens de raciocínio, o que "pode reduzir a qualidade da resposta 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 tua verificação: fazer parse do JSON, aplicar o patch e correr os testes, ou comparar com um esquema. Regista que modelo respondeu a cada tarefa. Ao fim de uma semana, a taxa de escalada por tipo de pedido diz-te que tipos encaminhar diretamente para o Astra.

Duas notas operacionais:

  • Mantém a mensagem developer idêntica nas duas chamadas. Não contes com a chamada ao Sol para aquecer uma cache para o Astra. Orçamenta a primeira chamada ao Astra à tarifa de entrada completa ou de escrita na cache; as escaladas seguintes que partilhem o mesmo prefixo podem depois lê-lo da cache.
  • Não mudes de modelo a meio de uma conversa. Escolhe o modelo no início de uma tarefa, ou reinicia 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?

Os mesmos endpoints, campos de pedido, janela de contexto (1.05M) e saída máxima (128K). O Astra custa quatro vezes mais por token e a OpenAI posiciona-o para as tarefas mais exigentes, enquanto o Sol é para a programação do dia a dia e fluxos de trabalho de agentes.

A GPT-6.2 Sol API é suficientemente boa para programar?

A OpenAI posiciona o Sol para a programação do dia a dia. Usa-o como predefinição e escala para o Astra quando os teus testes falharem; a taxa de escalada diz-te que tarefas precisam do Astra.

Quanto custa a mais a GPT-6.2 Astra API em relação ao Sol?

Quatro vezes mais por token em todos os medidores. No PoYo: $6.40 vs $1.60 de entrada e $32 vs $8 de saída por 1M de tokens.

Posso alternar entre o GPT-6.2 Sol e o Astra na mesma conversa?

Podes, mas a OpenAI avisa que as mudanças de modelo podem fazer a API Responses descartar itens de raciocínio. Reinicia 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 pedido na API?

Sim. Muda apenas o campo model entre gpt-6.2-sol e gpt-6.2-astra. Consulta o guia da GPT-6.2 API para veres os corpos de pedido completos.

Share: