GPT-6.2 Astra e Sol não são dois tamanhos da mesma compra. O Astra é o modelo da OpenAI para os projetos mais difíceis; o Sol é o modelo dela para o trabalho cotidiano e para agentes de alto volume. Nas tarifas de tabela padrão de contexto curto, o Astra custa quatro vezes mais por token de entrada e de saída. A pergunta prática, portanto, não é qual modelo soa mais forte, mas qual supera o seu critério de aceitação com o menor custo por tarefa utilizável — e quando uma saída melhor vale pagar um prêmio.
Escopo e evidência. A OpenAI publicou o lançamento do GPT-6.2 Astra e Sol em 17 de novembro de 2026. As especificações e os preços de tabela abaixo vêm do anúncio de lançamento da OpenAI e das páginas oficiais de modelo, verificados em 18 de novembro de 2026. Este é um guia de planejamento, não um relatório de benchmark: não executamos nenhum dos modelos, não medimos latência nem pontuamos saídas. O exemplo de custo é aritmética a partir das tarifas oficiais mais as premissas indicadas. O catálogo internacional da ToAPIs lista o Astra e o Sol; use o catálogo em tempo real para as variantes, tarifas e roteamento disponíveis na sua conta. Este artigo não afirma tarifas, caminhos de endpoint nem cobertura regional específicos da plataforma.
1. Os fatos oficiais que ancoram a decisão
O anúncio de lançamento da OpenAI posiciona o Astra para trabalho profissional complexo — apresentações, planilhas, documentos, programação, uso do computador e raciocínio visual — e o Sol para tarefas técnicas e não técnicas do dia a dia, incluindo fluxos agênticos de várias etapas. Ambos aceitam texto e imagens e retornam texto. As páginas oficiais de modelo listam os mesmos limites de contexto e de saída para cada um:
| Especificação | GPT-6.2 Astra | GPT-6.2 Sol |
|---|---|---|
| ID de modelo da API | gpt-6.2-astra | gpt-6.2-sol |
| Posicionamento da OpenAI | Os projetos mais difíceis, de ponta a ponta | Trabalho cotidiano e agentes em escala |
| Modalidades de entrada | Texto, imagem | Texto, imagem |
| Saída | Texto | Texto |
| Janela de contexto | 1,050,000 tokens | 1,050,000 tokens |
| Entrada máxima | 922,000 tokens | 922,000 tokens |
| Saída máxima | 128,000 tokens | 128,000 tokens |
| Corte de conhecimento | 18 de maio de 2026 | 1 de junho de 2026 |
| Ajuste de raciocínio | Máximo; none é rejeitado | Máximo; none é rejeitado |
| Ajuste fino | Não suportado | Não suportado |
A diferença econômica central é o preço, não um limite de contexto diferente:
| Tarifa oficial padrão de contexto curto | Astra | Sol | Astra / Sol |
|---|---|---|---|
| Entrada, por 1M de tokens | $8.00 | $2.00 | 4x |
| Entrada em cache, por 1M de tokens | $0.40 | $0.10 | 4x |
| Saída, por 1M de tokens | $40.00 | $10.00 | 4x |
| Escrita de cache de 30 minutos, por 1M de tokens | $10.00 | $2.50 | 4x |
Fonte: página de preços da API da OpenAI e páginas de modelo, verificadas em 18 de novembro de 2026. As tarifas estão em USD por milhão de tokens, antes de impostos e de qualquer cobrança da plataforma. São preços de tabela de referência, não uma cotação da ToAPIs.
A OpenAI também faz afirmações de desempenho relatadas pelo fornecedor. Diz que o Sol fica a 0.5 pontos do Astra no FrontierCode 2.0 da Cognition com cerca de um quinto do custo (ambos com raciocínio máximo), e relata o Astra com 1,318 Elo contra 1,259 do Sol na avaliação de preferência humana AA-3D da Artificial Analysis. São resultados relatados pelo fornecedor em configurações que não auditamos. Use-os como hipóteses; seus prompts, ferramentas e regras de aceitação podem produzir uma ordem diferente.
2. A diferença de preço de 4x: o que precisa ser verdade para o Astra
Nas tarifas de tabela padrão de contexto curto, o Astra e o Sol têm a mesma relação 4:1 em entrada, saída e entrada em cache. Se ambos os modelos consumirem a mesma quantidade de tokens cobráveis e precisarem do mesmo número de tentativas, o Astra não pode ter um custo por tarefa aceita menor a menos que a taxa de aceitação dele seja mais de quatro vezes a do Sol. Como a aceitação é limitada a 100%, isso se torna impossível quando a taxa de aceitação do Sol passa de 25%.
Essa afirmação tem escopo estreito: mesmo volume de tokens, mesmas tentativas, mesmas unidades cobráveis. Ainda assim é um ponto de partida útil, porque mostra o quão grande a diferença de qualidade precisa ser antes de o Astra ganhar apenas por custo. A sensibilidade do ponto de equilíbrio é assim:
| Taxa de aceitação do Sol | Aceitação do Astra necessária para igualar o custo por tarefa aceita do Sol |
|---|---|
| 10% | 40% |
| 15% | 60% |
| 20% | 80% |
| 25% | 100% |
| 30% | 120% (inalcançável) |
| 50% | 200% (inalcançável) |
Pressupõe contagens de tokens e tentativas idênticas por tarefa, e que cada tentativa é cobrada. Um perfil de tokens diferente muda o ponto de equilíbrio.
O enquadramento de ponto de equilíbrio não é um argumento de que o Astra está sobreprecificado. É um argumento contra tratar o rótulo "melhor modelo" como política de roteamento. O Astra pode ser racional quando a saída do Sol é inutilizável, quando uma resposta errada é caro, ou quando o reparo humano custa mais do que o prêmio de tokens. Raramente é o padrão para classificação, extração ou respostas curtas de suporte rotineiras.
Três ressalvas importam:
- A eficiência de tokens pode mover o ratio. Se o Astra alcança a aceitação com materialmente menos tokens de saída ou menos tentativas, o prêmio efetivo fica abaixo de 4x. Não temos medições pareadas, então não afirmamos um número.
- O ratio não é a fatura. Acima de 272,000 tokens de entrada, as tarifas de entrada e cache dobram e a saída custa 1.5x sobre toda a requisição. A relação 4:1 de tarifas de tabela se mantém, mas os custos absolutos sobem; não reutilize exemplos de contexto curto para trabalho de contexto longo.
- Outras unidades cobráveis podem quebrar o ratio. Chamadas de ferramentas, contêineres, busca de arquivos, modos batch ou Fast, Ultrafast, janelas em segundo plano, acréscimos regionais, impostos e taxas de plataforma ficam fora desta aritmética. Verifique a página de preços oficial e a tarifa da sua conta.
3. Mapa de cenários: onde cada modelo conquista seu lugar
A decisão fica mais clara quando você nomeia a carga de trabalho, o custo da falha e o volume. A tabela abaixo é uma política de partida, não uma afirmação sobre qualidade medida.
| Carga de trabalho | Comece com | Escale para o Astra quando | Principal impulsionador de custo |
|---|---|---|---|
| Suporte, classificação e extração de alto volume | Sol | Os casos ambíguos ou de alto valor falham na rubrica, ou uma resposta errada dispara uma revisão manual caro | Tentativas por tarefa e taxa de aceitação |
| Tarefas de código delimitadas, geração de testes, revisão de PR | Sol | A mudança abrange vários arquivos, exige julgamento de design, ou uma regressão é caro de detectar depois | Custo por tarefa aceita mais tempo de revisão |
| Apresentações, planilhas, memorandos, entregáveis para clientes | Sol para rascunhos | A fidelidade ao modelo, a síntese factual e a usabilidade na primeira passada determinam se o entregável serve | Retrabalho e tempo de revisão |
| Agentes de horizonte longo e fluxos com ferramentas | Sol para a execução | O planejamento ou os passos ambíguos falham repetidamente, ou o agente precisa de julgamento visual ou de uso do computador mais forte | Tokens acumulados e tentativas |
| Frontends visuais, 3D, CAD e interativos | Sol para páginas simples | A precisão espacial, a qualidade visual ou um uso detalhado do computador definem o resultado para o usuário | Tentativas e revisão humana |
| Processamento em lote offline | Sol | Um filtro de qualidade rejeita saídas demais do Sol, ou a tarefa é intrinsecamente de fronteira | Descontos de lote e taxa de rejeição |
Suporte e extração de alto volume: o Sol é a opção econômica padrão
Um pipeline de triagem de suporte ou de extração de faturas pode processar milhares de requisições curtas por dia, com alguns milhares de tokens de entrada e um rótulo curto ou uma saída JSON. A tarifa de $2/$10 do Sol é uma vantagem grande, e o contexto de 1.05M iguala o do Astra, então capacidade de contexto não é motivo para subir de nível. Escale apenas falhas específicas: uma falha de esquema em uma conta de alto valor, documentos de origem contraditórios, ou um erro que dispara revisão de reembolso ou de conformidade. Meça essa coorte; não mova a fila inteira porque uma demonstração parecia melhor.
Mudanças de código em todo o repositório: a qualidade aparece como tempo de revisão
Para um ajuste de uma linha, o Sol é a primeira tentativa sensata. Para uma refatoração de vários arquivos com design pouco claro, o custo real inclui a leitura de engenheiros sênior, a busca de pontos de chamada omitidos e a reparação de testes. Se o Sol precisa de várias rodadas enquanto o Astra produz uma mudança integrável em uma ou duas, o Astra pode sair mais barato por mudança aceita apesar do preço de tokens 4x. A aceitação precisa ser execução: aplique o patch e rode os testes em um ambiente descartável; um diff plausível não basta.
Entregáveis profissionais: o prêmio do Astra é mais fácil de justificar
Apresentações, livros de avaliação, resumos legais e memorandos para clientes têm custos de retrabalho altos. Uma apresentação que ignora o modelo ou um memorando que omite uma cláusula obrigatória podem consumir mais tempo humano do que a tarifa do modelo. A OpenAI posiciona o Astra para convenções profissionais e fidelidade a modelos. Ainda assim, faça uma revisão cega com o modelo real: se o rascunho do Sol serve, pague Sol; se precisa ser reestruturado, compare o tempo de revisão com o prêmio do Astra.
Agentes e fluxos visuais: separe o planejador do executor
Fluxos agênticos acumulam contexto, então a diferença de preço se compõe. Um padrão comum é Sol para chamadas de ferramentas rotineiras, extração e respostas curtas, com o Astra reservado para planejamento, decisões ambíguas ou passos visuais ou de uso do computador que determinam a trajetória. Defina orçamentos de tokens e tentativas por tarefa. Registre a trace completa e avalie a tarefa concluída, não a melhor mensagem intermediária.
4. Um exemplo de custo simples
Tome uma tarefa que usa 10,000 tokens de entrada e 2,000 de saída por chamada, nas tarifas de tabela padrão de contexto curto da OpenAI. Cada chamada é uma tentativa, e cada chamada é cobrada:
- Sol: $0.02 de entrada mais $0.02 de saída = $0.04 por chamada.
- Astra: $0.08 de entrada mais $0.08 de saída = $0.16 por chamada.
Se o Sol acerta na segunda tentativa, a tarefa custa $0.08. Se o Astra acerta na primeira tentativa, custa $0.16. Se o Sol precisa de cinco tentativas, custa $0.20 — mais do que a única chamada bem-sucedida do Astra. O prêmio, portanto, vale a pena apenas quando o Astra evita tentativas ou edição suficientes para fechar essa diferença. As contagens de tentativas são premissas para ilustrar, não medições; use os seus próprios registros.
Essa é a versão prática do custo por tarefa aceita: conte cada chamada cobrável e depois pese o total em dólares contra o tempo que você passa tornando o resultado utilizável.
Esses números são uma estimativa de planejamento a partir dos preços padrão de contexto curto publicados pela OpenAI, supondo entrada abaixo de 272,000 tokens por requisição. Excluem acertos e escritas de cache, cobranças de ferramentas, preços de lote, Fast, Ultrafast ou de janela em segundo plano (incluindo descontos), acréscimos regionais, impostos, taxas de plataforma e tempo de revisão ou edição humana. Não são uma cotação da ToAPIs; verifique o catálogo de modelos e a página de preços para as tarifas em tempo real da sua conta.
5. Como escolher em três passos
- Comece pelo Sol. Execute a tarefa real, ou uma amostra pequena dela, com o Sol usando seu prompt de produção e suas regras de saída. Registre se cada resultado passa, quantas chamadas levou e quanto tempo você passou consertando.
- Teste o Astra nas falhas específicas. Se o Sol falha por um motivo que um modelo mais forte poderia resolver — instruções ambíguas, julgamento de design fraco, um passo visual difícil — execute as mesmas entradas com o Astra. Não mova a carga de trabalho inteira porque uma demonstração parecia melhor.
- Compare o custo total de chamadas e o tempo de edição. Some cada chamada cobrável pela tarifa por chamada de cada modelo e depois coloque ao lado o tempo que você passa revisando ou reparando a saída. Escolha o Astra só quando o custo extra de chamadas é coberto por menos tentativas, menos edição ou menor custo de erro.
Para a integração de API, use o catálogo de modelos, a página de preços e a documentação da API. Para os IDs de modelo e uma primeira requisição, veja o guia da API do GPT-6.2 que acompanha este artigo. Verifique o catálogo em tempo real para as variantes, tarifas e regiões disponíveis na sua conta; este artigo não afirma tarifas, caminhos de endpoint nem cobertura regional específicos da plataforma.
6. Perguntas frequentes
O Astra vale 4x o preço?
Apenas quando a qualidade incremental muda o resultado o bastante para justificar o prêmio. Para trabalho rotineiro e bem especificado, o Sol é difícil de superar. Para entregáveis de alto valor, mudanças de código caras ou falhas repetidas do Sol, o Astra pode sair mais barato por tarefa realmente utilizável apesar da tarifa de tokens mais alta.
O preço menor do Sol significa menor qualidade em programação?
A OpenAI relata o Sol a 0.5 pontos do Astra no FrontierCode 2.0 com cerca de um quinto do custo (ambos no máximo). Essa é uma afirmação do fornecedor, não um resultado para o seu repositório. Teste a aplicabilidade dos patches, a taxa de testes que passam, o esforço de revisão e o risco de regressão.
Como devo contabilizar a entrada em cache?
A entrada em cache custa $0.40 por milhão no Astra contra $8.00 sem cache; o Sol custa $0.10 contra $2.00. As escritas de cache são à parte. Se você reutiliza prompts ou documentos longos, meça a taxa de acerto de cache em vez de supor preços sem cache. O exemplo pressupõe que não há benefício de cache.
E os prompts longos acima de 272K tokens?
Calcule à parte. Acima de 272,000 tokens de entrada, as tarifas de entrada e cache dobram e a saída custa 1.5x a tarifa de contexto curto sobre toda a requisição. A relação 4:1 de tarifas de tabela se mantém, mas os custos absolutos sobem; mantenha o trabalho de contexto longo fora das estimativas de contexto curto.
Posso usar a ToAPIs para executar esta comparação?
O catálogo internacional da ToAPIs lista o Astra e o Sol, mas este artigo não afirma tarifas, endpoints nem cobertura regional específicos da plataforma. Verifique o catálogo em tempo real e a página de preços. O harness de comparação do apêndice para desenvolvedores aponta por padrão para a API oficial da OpenAI; se você usar outro endpoint compatível com OpenAI, confirme os IDs de modelo, os campos e as unidades de cobrança.
7. Fontes e método
- OpenAI: Introducing GPT-6.2 Astra and Sol, publicado em 17 de novembro de 2026 — posicionamento de lançamento, disponibilidade e resultados relatados pelo fornecedor.
- Página de modelo da OpenAI: GPT-6.2 Astra — ID de modelo, limites de contexto, modalidades, ferramentas e preços, verificados em 18 de novembro de 2026.
- Página de modelo da OpenAI: GPT-6.2 Sol — ID de modelo, limites de contexto, modalidades, ferramentas e preços, verificados em 18 de novembro de 2026.
- Preços da API da OpenAI — termos de standard, cache, contexto longo, lote, Fast e Ultrafast, verificados em 18 de novembro de 2026.
- ToAPIs: guia da API do GPT-6.2 — configuração e preços específicos da plataforma; artigo complementar.
Nota sobre o método. Os números em dólares são aritmética determinística a partir das tarifas de tabela publicadas e das premissas de tokens e tentativas do exemplo. Não são faturas, cotações nem resultados medidos. Nenhuma inferência de modelo, medição de latência, pontuação de qualidade ou revisão cega foi realizada para este artigo, e o harness de comparação do apêndice para desenvolvedores não foi executado. Substitua as tarifas, as contagens de tokens e as contagens de tentativas pelos seus próprios dados de piloto antes de tomar uma decisão de produção.
Apêndice para desenvolvedores: execute sua própria comparação
O protocolo abaixo foi desenhado para produzir evidência para a sua própria carga de trabalho. Ele deliberadamente não é um ranking. A comparação não foi executada para este artigo, e aqui não se reportam saídas de modelo nem números de latência.
Desenho do teste
- Congele o conjunto de tarefas. Use entre 20 e 50 casos representativos, incluindo casos fáceis que protegem o comportamento existente e casos difíceis que distinguem os modelos. Remova dados confidenciais ou substitua por equivalentes sintéticos.
- Congele a requisição. Use o mesmo prompt de sistema, entrada de usuário, ferramentas, esquema de saída e orçamento de tokens para ambos os modelos sempre que os contratos permitirem. Registre as diferenças inevitáveis.
- Repita as tarefas não determinísticas. Preserve a distribuição e as falhas, não apenas a melhor saída.
- Pontue às cegas. Remova o rótulo do modelo antes da revisão. Uma tarefa passa só quando passa em todas as verificações obrigatórias; uma resposta polida que omite um campo, inventa um identificador ou falha um teste é uma falha.
- Conte as tentativas cobráveis e separe a latência. As tentativas falhas pertencem ao numerador do custo quando cobradas. Informe separadamente o tempo até o primeiro token, o tempo de conclusão e o tempo até um resultado aceito, e declare o que o cronômetro inclui.
Um conjunto mínimo de casos pode ser assim:
| Caso | Tarefa | Verificações de aceitação |
|---|---|---|
extract-01 | Extrair item e quantidade de uma mensagem curta de pedido | JSON válido; chaves exatas; a quantidade é um inteiro; sem valores inventados |
code-01 | Implementar uma função com condições de contorno | O patch aplica; os testes passam; a entrada inválida é rejeitada; sem mudanças não relacionadas |
clarify-01 | Responder a uma solicitação de status de pedido sem ID de pedido | Pede o ID; não o inventa; nenhuma ação de escrita |
memo-01 | Transformar um pacote de fontes fornecido em um memorando de uma página | Todas as seções obrigatórias presentes; números rastreáveis até a fonte; nenhuma afirmação sem suporte |
O harness chama o endpoint oficial de Chat Completions da OpenAI com ambos os IDs de modelo, registra o uso, a latência, os identificadores de modelo solicitados e retornados e os carimbos de tempo, e deixa accepted para um revisor humano. Ele exige uma chave de API e só faz chamadas cobráveis com --execute. estimate_cost ignora acertos de cache, descontos por modo de cobrança e taxas de plataforma, então concilie com o uso cobrado. Não use dados de produção; não presuma que um agregador preserva os IDs de modelo ou as tarifas.
#!/usr/bin/env python3
"""Reusable GPT-6.2 Astra vs Sol comparison harness.
The comparison was not executed for the accompanying article. Requires OPENAI_API_KEY and
explicit --execute consent because calls are billable. Acceptance is manual.
"""
from __future__ import annotations
import argparse
import json
import os
import time
import urllib.request
from datetime import datetime, timezone
from pathlib import Path
API_URL = os.environ.get("OPENAI_BASE_URL", "https://api.openai.com/v1").rstrip("/") + "/chat/completions"
MODELS = ("gpt-6.2-astra", "gpt-6.2-sol")
RATES = {
"gpt-6.2-astra": {"input": 8.00, "output": 40.00},
"gpt-6.2-sol": {"input": 2.00, "output": 10.00},
}
CASES = [
{
"id": "extract-01",
"system": "Return only valid JSON with exactly the keys item and quantity.",
"user": "Please order 3 blue mugs.",
"rubric": ["valid JSON", "item is blue mugs", "quantity is the integer 3"],
},
{
"id": "code-01",
"system": "Return a unified diff only. Do not include commentary.",
"user": (
"Implement merge_intervals(intervals) so overlapping or adjacent "
"intervals are merged. Reject invalid ranges. Include tests."
),
"rubric": ["patch applies", "tests pass", "invalid ranges rejected"],
},
{
"id": "clarify-01",
"system": "You are an order-support agent. Never invent identifiers.",
"user": "Where is my order?",
"rubric": ["asks for order ID", "does not invent an ID", "no write action"],
},
]
def estimate_cost(model: str, prompt_tokens: int, completion_tokens: int) -> float:
rate = RATES[model]
return (
prompt_tokens * rate["input"] + completion_tokens * rate["output"]
) / 1_000_000
def call_model(model: str, case: dict) -> dict:
body = json.dumps(
{
"model": model,
"messages": [
{"role": "system", "content": case["system"]},
{"role": "user", "content": case["user"]},
],
"max_completion_tokens": 8000, # fixed cap for this comparison
}
).encode("utf-8")
request = urllib.request.Request(
API_URL,
data=body,
headers={
"Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}",
"Content-Type": "application/json",
},
)
started = time.perf_counter()
with urllib.request.urlopen(request, timeout=180) as response:
payload = json.load(response)
elapsed = time.perf_counter() - started
usage = payload.get("usage", {})
prompt_tokens = usage.get("prompt_tokens", 0)
completion_tokens = usage.get("completion_tokens", 0)
return {
"requested_model": model,
"returned_model": payload.get("model"),
"api_url": API_URL,
"timestamp_utc": datetime.now(timezone.utc).isoformat(),
"case_id": case["id"],
"run": None,
"latency_seconds": round(elapsed, 3),
"prompt_tokens": prompt_tokens,
"completion_tokens": completion_tokens,
"cost_usd": round(estimate_cost(model, prompt_tokens, completion_tokens), 6),
"output": payload["choices"][0]["message"]["content"],
"rubric": case["rubric"],
"accepted": None,
"reviewer": None,
"review_notes": None,
}
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument("--execute", action="store_true", help="make billable API calls")
parser.add_argument("--repeats", type=int, default=1)
parser.add_argument("--out", default="gpt-6-2-runs.jsonl")
args = parser.parse_args()
if not args.execute:
print("Dry plan only. Re-run with --execute after checking access, budget and data rules.")
for case in CASES:
print(json.dumps({"case": case["id"], "models": MODELS, "repeats": args.repeats}))
return
if not os.environ.get("OPENAI_API_KEY"):
raise SystemExit("Set OPENAI_API_KEY first.")
output = Path(args.out)
with output.open("a", encoding="utf-8") as handle:
for case in CASES:
for model in MODELS:
for run in range(args.repeats):
record = call_model(model, case)
record["run"] = run + 1
handle.write(json.dumps(record, ensure_ascii=False) + "\n")
print(json.dumps({
"case_id": record["case_id"],
"model": record["requested_model"],
"latency_seconds": record["latency_seconds"],
"cost_usd": record["cost_usd"],
}))
print(f"Wrote {output}. Fill 'accepted' manually against each rubric before comparing costs.")
if __name__ == "__main__":
main()
Depois da revisão, calcule o número central para a decisão de roteamento:
import json
from pathlib import Path
rows = [json.loads(line) for line in Path("gpt-6-2-runs.jsonl").read_text().splitlines()]
if not rows or any(type(row["accepted"]) is not bool for row in rows):
raise SystemExit("Review every row before comparing costs.")
for model in sorted({row["requested_model"] for row in rows}):
model_rows = [row for row in rows if row["requested_model"] == model]
accepted = sum(row["accepted"] is True for row in model_rows)
estimated = sum(row["cost_usd"] for row in model_rows)
per_accepted = estimated / accepted if accepted else None
print(model, {"accepted": accepted, "estimated_usd": round(estimated, 4),
"cost_per_accepted": round(per_accepted, 4) if per_accepted is not None else None})
O harness não testa a execução de ferramentas, porque executar código ou comandos de shell gerados pelo modelo traz problemas de segurança e reprodutibilidade. Se o seu fluxo de trabalho usa ferramentas, avalie a trace de ferramentas separadamente: argumentos válidos, autorização, efeitos colaterais, tentativas e se uma pergunta de esclarecimento era a ação correta. Um modelo que escreve uma resposta perfeita mas chama uma ferramenta destrutiva de forma errada não passou na tarefa.







