GPT-6.2 Sol vs. GPT-6 Sol em 32 testes: vale pagar mais pela precisão?
32 testes no mesmo canal: GPT-6.2 Sol 16/16, GPT-6 Sol 13/16. Três erros, tempos por tarefa, descontos, custos reais e migração de reasoning_effort.

Se o GPT-6 Sol já dá conta do trabalho do dia a dia, a decisão de migrar para o GPT-6.2 Sol deve partir de tarefas concretas. O novo modelo corrige os erros de cálculo do anterior? Reduz o tempo de espera? O custo adicional compensa?
Nos 32 testes realizados pelo mesmo canal da Crazyrouter, o GPT-6.2 Sol acertou 16/16 tarefas por completo, ante 13/16 do GPT-6 Sol. Na tarefa de otimização com restrições, o novo modelo reduziu o tempo médio de resposta em 38.4%, mas o custo efetivo da rodada foi 53.2% maior. Para trabalhos que exigem contagens exatas e soluções ótimas, esses resultados justificam testar primeiro o 6.2 Sol. Se o 6 Sol já atende aos critérios de aceitação de forma consistente e o custo é prioridade, ainda vale mantê-lo.
Esta rodada usou as mesmas oito categorias de tarefas e os mesmos critérios de avaliação do comparativo anterior dos modelos Astra, mas todas as requisições dos modelos Sol foram executadas novamente. Como os horários dos testes e o estado do cache diferiram entre as séries, não convém juntar os custos dos dois artigos em um ranking.
O que mudou nas especificações oficiais? A janela e os preços-base de entrada e saída são iguais#
Os dados foram conferidos em 20 de novembro de 2026, diretamente na documentação oficial dos dois modelos.[1][2]
| Item | GPT-6.2 Sol | GPT-6 Sol |
|---|---|---|
| Nome do modelo | gpt-6.2-sol | gpt-6-sol |
| Entrada / saída | Texto e imagens na entrada, texto na saída | Texto e imagens na entrada, texto na saída |
| Janela de contexto | 1,050,000 tokens | 1,050,000 tokens |
| Entrada máxima / saída máxima | 922,000 / 128,000 tokens | 922,000 / 128,000 tokens |
| Data de corte do conhecimento | 2026-06-01 | 2026-04-20 |
| Tarifa oficial de entrada sem cache | $2 por milhão de tokens | $2 por milhão de tokens |
| Tarifa oficial de leitura do cache | $0.10 por milhão de tokens | $0.20 por milhão de tokens |
| Tarifa oficial de saída | $10 por milhão de tokens | $10 por milhão de tokens |
reasoning_effort: none | A documentação oficial informa que esse valor é rejeitado | A documentação oficial lista esse valor como compatível |
Os preços são do plano Standard, na faixa de até 272K tokens de entrada. A documentação de ambos os modelos informa que, acima de 272K tokens de entrada, as tarifas de entrada e leitura do cache dobram, enquanto a tarifa de saída passa a ser 1.5 vez a da faixa de entradas mais curtas.[1][2]
É fácil interpretar esses dados como se o novo modelo fosse mais barato. As tarifas oficiais dos dois modelos Sol são iguais para entrada sem cache e saída. A tarifa de leitura do cache caiu 50%. A economia depende da proporção de tokens atendida pelo cache, do consumo efetivo de tokens e dos descontos da plataforma usada.
As páginas oficiais também listam recursos de imagem e de uso de ferramentas. Este artigo testou apenas requisições de texto via Chat Completions. Os demais recursos listados nas páginas oficiais não foram validados na Crazyrouter.
Configuração dos testes e verificações separadas de parâmetros e código#
O teste principal foi executado em 20 de novembro de 2026, das 12:55 às 12:59, no horário de Pequim. Primeiro, verificamos os dois modelos via /v1/models. Em seguida, usamos o mesmo canal do provedor para compará-los.
| Condição | Configuração desta rodada |
|---|---|
| Acesso ao serviço | Crazyrouter, https://api.crazyrouter.com/v1 |
| Endpoint | POST /chat/completions |
| Controle de roteamento | Fixamos o mesmo canal do provedor e confirmamos individualmente que os 32 registros de cobrança indicavam esse canal |
| Prompts | Mensagens de sistema e de usuário idênticas para cada tarefa |
| Esforço de raciocínio / limite de saída | reasoning_effort: high e max_completion_tokens: 8192 |
| Modo de resposta | Sem streaming, stream: false |
| Distribuição das requisições | 8 categorias de tarefas × 2 rodadas por modelo, em ordem aleatória e com concorrência total de 2 |
| Critério de aprovação da tarefa | HTTP 200, finish_reason=stop e JSON válido com cada campo igual ao da resposta esperada, definida previamente |
As tarefas cobriram consulta a regras, verificação de premissa incorreta, otimização em grafo de dependências, seleção com restrições, reconstituição de cobrança, visibilidade de transações, ordem da deduplicação e limites de intervalos. As respostas esperadas foram definidas antes do envio das requisições e ficaram fora dos prompts enviados aos modelos.
O tempo foi medido do envio da requisição pelo cliente até o recebimento da resposta completa. A medição inclui rede, fila, inferência e geração da saída, e é diferente da latência até o primeiro token. As seis primeiras tarefas vieram de um conjunto de testes anterior, e o cache não foi limpo. Os custos, portanto, refletem a execução real com o cache naquele estado, sem um cenário controlado de cache frio.
A compatibilidade de parâmetros e o exemplo de código foram testados separadamente, fora das 32 requisições principais. Algumas requisições complementares coincidiram com o horário do teste principal, portanto a medição de desempenho não ocorreu em condições de isolamento rigoroso. A maior entrada reportada no teste principal foi de 14,377 tokens. O teste não verificou o contexto de um milhão de tokens, a modificação de repositórios inteiros nem a execução de código gerado pelos modelos.
Resultados do teste: 6.2 Sol acertou todas as tarefas e 6 Sol errou em duas categorias#
| Tarefa | Acertos do 6.2 Sol | Acertos do 6 Sol | Tempo médio do 6.2 | Tempo médio do 6 |
|---|---|---|---|---|
| Consulta a uma tabela extensa de regras | 2/2 | 2/2 | 15.60 segundos | 15.12 segundos |
| Correção de premissa incorreta | 2/2 | 0/2 | 15.39 segundos | 19.60 segundos |
| Otimização em grafo de dependências | 2/2 | 2/2 | 8.43 segundos | 9.74 segundos |
| Seleção ótima com restrições | 2/2 | 1/2 | 20.24 segundos | 32.86 segundos |
| Reconstituição de cobrança | 2/2 | 2/2 | 14.44 segundos | 11.32 segundos |
| Visibilidade de transações | 2/2 | 2/2 | 8.54 segundos | 6.20 segundos |
| Deduplicação antes da filtragem | 2/2 | 2/2 | 8.79 segundos | 6.52 segundos |
| Análise dos limites de intervalos | 2/2 | 2/2 | 8.51 segundos | 5.70 segundos |

Os tempos incluem as requisições com respostas incorretas. Cada célula representa apenas duas medições, portanto tempos próximos são insuficientes para indicar uma vantagem consistente.
As 32 requisições dos dois modelos retornaram HTTP 200, produziram JSON válido e terminaram com stop. A diferença apareceu na correção das respostas. Os três erros do GPT-6 Sol foram de conteúdo.
Primeiro erro: o modelo rejeitou a premissa incorreta, mas errou a contagem#
A tarefa apresentava 360 regras e pedia para verificar a afirmação de que “exatamente duas regras com status SETTLED são acionadas quando delay=8” e retornar o total de regras que atendiam à condição.
Os status das regras se repetem a cada cinco entradas, o que dá 72 regras com status SETTLED. Como todos os valores de delay_gt estão entre 1 e 7, as 72 regras satisfazem a condição de acionamento quando delay=8.
Os dois modelos rejeitaram corretamente a afirmação de que eram “exatamente duas”, mas chegaram a contagens diferentes.
| Campo retornado | Resposta esperada | Duas rodadas do GPT-6.2 Sol | Duas rodadas do GPT-6 Sol |
|---|---|---|---|
exactly_two | false | false em ambas | false em ambas |
matching_count | 72 | 72 e 72 | 69 e 71 |
winner_policy_specified | false | Correto em ambas | Correto em ambas |
max_days_among_matches | 116 | Correto em ambas | Correto em ambas |
Olhando apenas se o modelo contestou a afirmação do colega, as quatro respostas pareciam corretas. Na verificação campo a campo, a versão anterior deixou regras de fora da contagem nas duas rodadas e, por isso, foi reprovada na tarefa em ambas.
Essa diferença é particularmente relevante na conferência de cobranças, na auditoria de regras e na filtragem em lote. Uma resposta plausível ainda pode trazer uma contagem errada, e até um JSON válido precisa passar pela validação das regras de negócio.
Segundo erro: o modelo encontrou uma solução viável, mas deixou passar a ótima#
A tarefa de seleção com restrições pedia o conjunto de maior valor total entre 12 itens, respeitando um limite de peso, um máximo de 5 itens e as relações de dependência e de exclusão mútua.
Ao enumerar todos os 4,096 subconjuntos, chegamos a uma única solução ótima.
{"best_value":78,"optimal_sets":[[0,2,6,9,11]]}
O GPT-6.2 Sol acertou nas duas rodadas. O GPT-6 Sol acertou na primeira e retornou o seguinte na segunda.
{"best_value":77,"optimal_sets":[[0,2,4,6,9],[0,4,6,8,11]]}
A solução da segunda rodada respeitava as restrições e de fato somava 77, mas o modelo deixou passar a solução de valor 78. Ele encontrou uma boa solução viável e ficou aquém do objetivo da tarefa, que exigia a solução ótima.
Nessa tarefa, o 6.2 Sol levou em média 20.24 segundos, ante 32.86 segundos do 6 Sol, uma redução de cerca de 38.4%. O resultado justifica incluir problemas com restrições semelhantes nos testes do novo modelo. Duas rodadas são insuficientes para afirmar que ele será mais rápido ou preciso em todos os problemas de otimização.
O ganho de velocidade variou: a média caiu um pouco e a mediana subiu#
| Estatísticas das 16 requisições principais por modelo | GPT-6.2 Sol | GPT-6 Sol |
|---|---|---|
| HTTP 200 / JSON válido | 16/16 | 16/16 |
| Tarefas acertadas por completo | 16/16 | 13/16 |
| Taxa de acerto integral nesta rodada | 100% | 81.25% |
| Tempo médio até a resposta completa | 12.49 segundos | 13.38 segundos |
| Tempo mediano até a resposta completa | 12.48 segundos | 11.14 segundos |
| Menor / maior tempo | 5.29 / 20.28 segundos | 5.58 / 34.79 segundos |
O 6.2 Sol foi mais rápido em média em três categorias: correção de premissa incorreta, grafo de dependências e seleção com restrições. Nas outras cinco, não teve vantagem no tempo médio. A redução na espera da tarefa de seleção com restrições baixou a média geral, enquanto a mediana subiu.
Nesta rodada, a vantagem da migração foi a maior precisão em tarefas específicas e a redução da espera na resolução do problema mais demorado com restrições. Os resultados de 100% e 81.25% descrevem apenas esta amostra. Eles são insuficientes para medir a capacidade geral dos modelos ou garantir sua confiabilidade no longo prazo.
Custos: os preços oficiais de entrada sem cache e saída são iguais, mas os descontos e o consumo mudam a conta#
No grupo default da Crazyrouter consultado nesta rodada, o GPT-6 Sol tem 35% de desconto (paga-se 65% da tarifa), enquanto o GPT-6.2 Sol segue a tarifa integral. Na faixa de entradas mais curtas, os preços na Crazyrouter, com os descontos aplicáveis, são os seguintes.
| Por milhão de tokens | GPT-6.2 Sol | GPT-6 Sol |
|---|---|---|
| Entrada sem cache | $2.00 | $1.30 |
| Leitura do cache | $0.10 | $0.13 |
| Saída | $10.00 | $6.50 |
A leitura do cache é mais barata no novo modelo, enquanto a entrada sem cache e a saída custam menos na versão anterior. Para estimar seus próprios custos, consulte a página de preços da Crazyrouter. A versão do modelo e o preço oficial, por si sós, são insuficientes para essa estimativa.
Associamos as 32 requisições principais a seus registros de consumo pelo ID da requisição. Os valores abaixo foram calculados dividindo os débitos efetivos pelo fator quota_per_unit=500000 da Crazyrouter.
| Uso efetivo e custo | GPT-6.2 Sol | GPT-6 Sol |
|---|---|---|
| Requisições principais | 16 | 16 |
| Tokens de entrada reportados pelo provedor | 125,998 | 112,964 |
| Dos quais, tokens lidos do cache | 56,576 | 55,168 |
| Proporção da entrada atendida pelo cache | 44.9% | 48.8% |
| Tokens de saída (incluindo os de raciocínio) | 5,460 | 7,325 |
| Custo efetivo | $0.199104 | $0.129922 |

O total corresponde ao débito efetivo, e os itens da cobrança foram reconstituídos a partir dos registros. Pequenas diferenças decorrem do arredondamento. O custo inclui as requisições com respostas incorretas e exclui as verificações de parâmetros, o exemplo de código e a geração da imagem de capa.
Nesta rodada, o novo modelo custou 53.2% a mais e acertou as tarefas que a versão anterior não conseguiu acertar em todas as tentativas. As três respostas incorretas do modelo anterior também foram cobradas. A tabela deixa de fora os custos de revisão manual, novas tentativas e correções em uso real.
Com o mesmo prompt visível, o provedor reportou volumes diferentes de tokens de entrada, e o novo modelo usou menos tokens de saída. A causa específica da diferença nos volumes de entrada reportados ficou indeterminada, e as condições de cache frio ou aquecido não foram padronizadas. O aumento de 53.2% descreve apenas esta execução e pode variar para outros usuários.
Antes de migrar, revise o uso de none na configuração anterior#
A documentação oficial indica que o GPT-6 Sol aceita reasoning_effort: none e que o GPT-6.2 Sol rejeita esse valor.[1][2] Enviamos pelo mesmo canal uma requisição curta de JSON para cada modelo, com none definido explicitamente.
| Verificação adicional do parâmetro | GPT-6.2 Sol | GPT-6 Sol |
|---|---|---|
| Status HTTP | 400 | 200 |
| Retorno | provider_temporarily_unavailable, com mensagem genérica de indisponibilidade do serviço | {"ok":true}, com encerramento normal |
O resultado é compatível com a diferença de parâmetros indicada na documentação oficial, mas a Crazyrouter converteu o erro do 6.2 em uma mensagem genérica que não mencionava none. A mensagem de indisponibilidade temporária, por si só, é insuficiente para identificar a causa do erro. Evite repetir indefinidamente a requisição com a mesma configuração incompatível.
Antes da migração, confira os parâmetros das requisições existentes e valide a chamada com um nível de esforço explicitamente aceito. O teste principal e o exemplo deste artigo usaram high. A página oficial do GPT-6 Sol também indica restrições de nível de esforço para chamadas de função via Chat Completions. Aplicações que usam ferramentas precisam de testes de regressão separados, pois este artigo não verificou chamadas de ferramentas nem a Responses API.
Um exemplo executado com os dois modelos#
O exemplo abaixo pede para mesclar intervalos semiabertos sobrepostos ou adjacentes. Para executá-lo, instale requests e defina sua chave na variável de ambiente CRAZYROUTER_API_KEY. O endereço da API não inclui parâmetros UTM.
import json
import os
import requests
BASE_URL = "https://api.crazyrouter.com/v1"
MODELS = ["gpt-6.2-sol", "gpt-6-sol"]
PROMPT = ('Merge overlapping OR TOUCHING half-open intervals [[-3,2],[1,5],[5,9]] into maximal intervals. '
'Return JSON only: {"merged":[[start,end]],"length":integer}.')
def run():
session = requests.Session()
session.trust_env = False
results = []
for model in MODELS:
response = session.post(
BASE_URL + "/chat/completions",
headers={"Authorization": "Bearer " + os.environ["CRAZYROUTER_API_KEY"]},
json={
"model": model,
"messages": [{"role": "user", "content": PROMPT}],
"reasoning_effort": "high",
"max_completion_tokens": 8192,
"stream": False,
},
timeout=(15, 180),
)
response.raise_for_status()
data = response.json()
choice = data["choices"][0]
if choice["finish_reason"] != "stop":
raise RuntimeError("Incomplete output: " + str(choice["finish_reason"]))
answer = json.loads(choice["message"]["content"])
assert answer == {"merged": [[-3, 9]], "length": 12}, answer
result = {"model": model, "answer": answer,
"request_id": response.headers.get("x-oneapi-request-id")}
print(json.dumps(result, ensure_ascii=False))
results.append(result)
return results
if __name__ == "__main__":
run()
A versão final foi validada com uma chamada a cada modelo. Ambos retornaram {"merged":[[-3,9]],"length":12} e finish_reason=stop. As duas chamadas usaram o roteamento normal de usuário e foram contabilizadas separadamente do teste principal, que usou um canal fixo.
O prompt inicial pedia apenas para “mesclar intervalos semiabertos”. O 6.2 Sol retornou [[-3,5],[5,9]]. O comprimento continuava sendo 12, mas a saída falhou na verificação que exigia um único intervalo. Especificamos então que era preciso “mesclar intervalos sobrepostos ou adjacentes para obter intervalos maximais”, e os dois modelos passaram. O histórico dessa revisão do exemplo foi preservado. A tarefa de intervalos do teste principal já exigia a fusão de intervalos adjacentes desde o início, e seus resultados foram mantidos sem alterações na tarefa nem novas execuções para substituí-los.
Os campos da integração podem ser conferidos na documentação da API da Crazyrouter. Equipes que usam Codex (em inglês) ou Cursor (em inglês) devem executar testes de regressão com suas próprias tarefas e ferramentas. A aprovação de um exemplo só de texto é insuficiente para validar todo o fluxo de trabalho de um agente.
Quando vale a pena migrar para o GPT-6.2 Sol?#
| Cenário de uso | Escolha respaldada pelos resultados desta rodada |
|---|---|
| Contagem exata ou filtragem de regras com histórico de omissões | Teste primeiro o 6.2 Sol e mantenha a verificação automatizada |
| Seleção ótima com dependências e exclusões mútuas | Teste o 6.2 Sol, que acertou nas duas rodadas e teve menor tempo médio de resposta |
| Processamento rotineiro de dados já aprovado nos testes de regressão, com prioridade para o custo | Considere manter o 6 Sol, cuja tarifa com desconto na Crazyrouter está mais baixa |
| A prioridade é reduzir o tempo de resposta | Meça o desempenho nas suas tarefas. Nesta rodada, o novo modelo foi mais rápido em média em apenas três categorias |
As requisições anteriores sempre usavam reasoning_effort: none | Ajuste o nível de esforço de raciocínio antes de trocar o nome do modelo |
| A aplicação exige interpretação de imagens, chamadas de ferramentas ou agentes em execução prolongada | Valide esses recursos separadamente, pois ficaram fora do escopo desta rodada |
Você pode usar o Model Arena para uma primeira comparação com as mesmas tarefas e depois montar um conjunto fixo de testes de regressão com casos reais em que o modelo falhou. Definir critérios de aceitação para cada campo crítico ajuda a avaliar se a migração resolveu o problema, algo difícil de determinar apenas pela fluidez de uma resposta isolada.
Como reproduzir a tarefa de otimização com restrições#
O prompt de usuário completo está abaixo. O teste principal usou o nível de raciocínio high, um limite de saída de 8192 tokens e uma mensagem de sistema que exigia apenas JSON como resposta. O gabarito foi usado apenas na avaliação local e ficou fora das mensagens enviadas aos modelos.
Items IDs 0..11 have weights [4, 7, 2, 9, 5, 3, 8, 6, 4, 7, 1, 5] and values [13, 18, 7, 26, 14, 9, 23, 16, 12, 20, 4, 15]. Select total weight <=26 and at most 5 items. Constraints: selecting 3 requires 1; 6 and 7 cannot both be selected; selecting 9 requires 2; at least one of 0 and 4 must be selected. Maximize total value. Return JSON with best_value and optimal_sets (ALL optimal ID lists sorted ascending, and lists lexicographically sorted).
Esta é a resposta esperada, calculada previamente.
{"best_value": 78, "optimal_sets": [[0, 2, 6, 9, 11]]}
Para verificar a solução ótima, enumere todos os subconjuntos dos 12 itens candidatos e filtre-os pelas restrições de peso, quantidade, dependência e exclusão mútua. As requisições e respostas originais e os registros de cobrança de cada chamada foram arquivados para conferência. As tabelas e os gráficos deste artigo foram elaborados a partir desses registros.
As duas requisições independentes do exemplo mínimo de chamada têm os seguintes IDs.
gpt-6.2-sol:8f830a249943b0b13a1ec388dbf882f6.gpt-6-sol:f08d86841a979c9bf2d8928816e31789.
Perguntas frequentes#
O GPT-6.2 Sol é mais preciso que o GPT-6 Sol?#
Nesta rodada com oito categorias de tarefas e duas tentativas por categoria, o novo modelo acertou 16/16, ante 13/16 da versão anterior. A diferença se concentrou na contagem de regras e na otimização com restrições. Essa taxa de acerto vale apenas para as tarefas testadas.
Quanto mais rápido é o GPT-6.2 Sol em relação ao GPT-6 Sol?#
Nesta rodada, o tempo médio na tarefa de seleção com restrições caiu 38.4%, e a média de todas as requisições caiu cerca de 6.6%. A mediana, porém, aumentou de 11.14 segundos para 12.48 segundos, e o novo modelo foi mais rápido apenas em algumas categorias.
O preço da API do GPT-6.2 Sol caiu?#
Os preços oficiais de entrada sem cache e de saída continuam iguais. A leitura do cache caiu de 0.10 por milhão de tokens. Na Crazyrouter, o modelo anterior tem atualmente 35% de desconto (paga-se 65% da tarifa), e o custo total efetivo do novo modelo foi maior nesta rodada.
Vale a pena pagar mais?#
Se erros de contagem ou soluções abaixo do ótimo causarem prejuízos no seu negócio, vale incluir o novo modelo nos testes. Se as tarefas atuais já passam de forma consistente, você pode manter o modelo anterior por enquanto. Esta rodada não mediu os custos de correção manual nem de novas tentativas, portanto o benefício precisa ser avaliado em cada aplicação.
Por que o artigo considera a resposta errada se a chamada à API foi bem-sucedida?#
HTTP 200, JSON válido e encerramento normal indicam apenas que a requisição foi concluída. Nas três falhas, a versão anterior retornou respostas com a estrutura esperada, mas com valores de campos diferentes dos definidos no gabarito. Por isso, as tarefas foram consideradas incorretas por completo nessas tentativas.
Posso simplesmente trocar o nome do modelo para gpt-6.2-sol?#
Você pode manter a URL base e a forma de fazer chamadas de texto. Antes de trocar o modelo, verifique o parâmetro de raciocínio. A documentação oficial informa que o novo modelo não aceita none, e a verificação na Crazyrouter retornou HTTP 400. Streaming, ferramentas, imagens e outros recursos ainda precisam de testes separados.
Fontes
- OpenAI: documentação do modelo GPT-6.2 Sol, consultada em 2026-11-20.
- OpenAI: documentação do modelo GPT-6 Sol, consultada em 2026-11-20.
- PostgreSQL: isolamento de transações e Read Committed, usado para conferir as regras da tarefa sobre transações.
Por Brian J. Os testes foram executados por scripts automatizados. Este artigo registra o desempenho efetivo do serviço com o roteamento da Crazyrouter. Os pesos dos modelos do provedor não passaram por auditoria independente. Cada tarefa foi executada apenas duas vezes por modelo, em um único canal e período, sem isolamento do cache de execuções anteriores. As requisições e respostas originais, os gabaritos e os registros de cobrança com dados sensíveis removidos foram arquivados. A revisão das informações sujeitas a mudanças está prevista para 2026-12-20.
Implementation Guides
Podcast
AI Dev Tools: The Crazyrouter Podcast
Episódios curtos (em inglês) para desenvolvedores: APIs de IA, gateways, controle de custos e ferramentas de código.
Episódios mais recentes
EP196 · 29 de out. de 2026 · 6:53
AI API Security Posture — Turn Controls Into Continuous Evidence
A practical guide to AI API security posture: inventory exposure, verify controls continuously, protect keys and data, constrain tools, and turn security assumptions into evidence that operators can act on.
EP195 · 28 de out. de 2026 · 7:21
AI API Policy Drift — Detect When Production Rules Stop Matching Intent
A practical guide to policy drift in AI APIs: version routing and safety rules, detect stale enforcement, compare intended and observed behavior, and restore control before small gaps become incidents.





