GPT-5.5 vs Claude Sonnet 4.6 vs Gemini 3.1 Pro: O que nenhum benchmark revela

Existe um tipo particular de reunião que acontece em toda equipe que constrói em cima de LLMs de fronteira. Alguém compartilha o último ranking de benchmarks. Outra pessoa aponta que as posições mudaram desde o mês passado. Uma terceira observa que o modelo que a equipe está usando caiu duas posições em alguma métrica de que nenhum deles tinha ouvido falar três semanas atrás. Ao final da reunião, ninguém tem certeza se deve migrar, e a conversa é remarcada para o próximo trimestre.

O problema dessa reunião não são as pessoas que participam dela. É que benchmarks medem tarefas sintéticas, e o seu produto não é uma tarefa sintética. O ranking mostra como um modelo se sai no MMLU, no SWE-bench Verified, no GPQA Diamond — testes projetados por pesquisadores para serem mensuráveis entre modelos. Nenhum desses testes se parece com os prompts que a sua aplicação realmente envia em produção. Nenhum deles captura como um modelo lida com o tipo específico de entrada bagunçada, moldada pelo domínio, que seus usuários geram.

Este artigo percorre exatamente o exercício que benchmarks não conseguem fazer. Três prompts concretos, pensados para serem enviados a GPT-5.5, Claude Sonnet 4.6 e Gemini 3.1 Pro por meio do mesmo endpoint compatível com OpenAI, com as mesmas configurações de temperatura e sem prompt adicional. Os prompts abrangem três categorias que cobrem a maioria dos workloads de produção: extração estruturada de um documento bagunçado, uma tarefa de planejamento com raciocínio pesado e geração de código sob restrições. As observações abaixo são os padrões comportamentais que equipes que rodam esse tipo de comparação relatam consistentemente — os padrões que você mesmo veria se executasse esses prompts na sua própria configuração.

Nos rankings, esses três modelos marcam dentro de 0,8 ponto percentual um do outro no SWE-bench Verified. Na prática, comportam-se de maneira muito diferente. A escolha entre eles não é sobre qual pontua mais alto nos benchmarks — é sobre qual padrão de comportamento se ajusta ao seu workload.

O que os benchmarks medem e o que deixam de fora

Benchmarks existem porque precisam existir. Os provedores de modelos precisam de testes padronizados para fazer reivindicações de capacidade, pesquisadores precisam deles para publicar comparações, e o resto de nós precisa deles para ter qualquer ponto de partida objetivo para avaliar modelos. Eles são úteis. Também são incompletos de maneiras que importam para uso em produção.

Três limitações específicas valem ser ditas explicitamente, porque cada uma aparece nos exemplos de prompt abaixo.

• Benchmarks medem capacidades isoladas, não padrões de comportamento. O SWE-bench Verified informa se um modelo consegue resolver um determinado tipo de issue no GitHub. Não diz se o modelo tende a superengenheirar problemas simples, se faz perguntas de esclarecimento quando o prompt é ambíguo, ou se produz uma saída que corresponde à estrutura que você pediu de primeira. Essas são as coisas que você vai observar diariamente em produção.
• Benchmarks são alvo de ajuste fino. Quando um lançamento de modelo destaca sua pontuação em um benchmark específico, isso sinaliza que o modelo foi pelo menos parcialmente otimizado para aquele benchmark. Desempenho no mundo real e desempenho em benchmark podem divergir — às vezes substancialmente — quando o modelo sai das condições para as quais o benchmark foi projetado.
• Benchmarks agregam. Uma diferença de 0,8 ponto percentual na pontuação do SWE-bench Verified pode esconder o fato de que o Modelo A é muito melhor em uma categoria específica de tarefa e pior em outra, enquanto o Modelo B é consistente em toda a linha. A agregação colapsa informações de que você precisa para tomar uma decisão.

O exercício abaixo foi projetado para evidenciar exatamente o tipo de informação que os benchmarks agregam e escondem. O objetivo não é declarar um vencedor — é mostrar as perguntas que você deveria fazer quando executar o mesmo exercício nos seus próprios prompts.

A configuração

Três prompts, escolhidos porque mapeiam para categorias que a maioria dos workloads de produção atinge. A configuração: cada prompt enviado aos três modelos com parâmetros idênticos (temperatura 0,3, sem override de system prompt, formato de resposta padrão), acessados por um único endpoint compatível com OpenAI para que a comparação permaneça equivalente — sem peculiaridades específicas de SDK do provedor, sem mapeamentos de parâmetros diferentes, sem risco de um modelo receber tratamento especial por causa de como a requisição é construída.

Os próprios prompts estão abaixo, como blocos de código que você pode copiar e executar. As descrições comportamentais que seguem cada um são os padrões que equipes relatam consistentemente ao rodar esse tipo de comparação — padrões documentados em vários estudos de terceiros em 2026, e o tipo de coisa que você deve esperar ver quando rodar esses prompts na sua própria configuração. Rodar você mesmo é o ponto; o artigo existe para dar o arcabouço e os prompts iniciais para fazer isso.

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["COMET_API_KEY"],  # or replace with your API key
    base_url="https://api.cometapi.com/v1",  # one endpoint, multiple models
)

MODELS = [
    "gpt-5.5",
    "claude-sonnet-4-6",
    "gemini-3.1-pro",
]


def run_comparison(prompt: str, temperature: float = 0.3) -> dict[str, str]:
    """
    Send the same prompt to all three models and return their responses.
    """
    responses = {}

    for model in MODELS:
        result = client.chat.completions.create(
            model=model,
            messages=[
                {
                    "role": "user",
                    "content": prompt,
                }
            ],
            temperature=temperature,
        )

        responses[model] = result.choices[0].message.content

    return responses


# Example usage
if __name__ == "__main__":
    prompt = "Summarise the key risks in this contract."

    outputs = run_comparison(prompt)

    for model, response in outputs.items():
        print(f"\n--- {model} ---")
        print(response)

Prompt 1: Extração estruturada de um documento bagunçado

Esta é a tarefa básica de metade dos recursos de LLM lançados em 2026. Pegue uma entrada não estruturada — um e-mail, um tíquete de suporte, uma transcrição de reunião, um formulário digitalizado — e extraia campos específicos para um objeto estruturado. O prompt abaixo pede que cada modelo extraia sete campos de um e-mail de suporte ao cliente deliberadamente bagunçado, contendo informações parciais, sinais conflitantes e um campo que não está presente no texto-fonte.

O prompt

You are processing customer support emails. Extract the followingseven fields from the email below into a JSON object with exactlythese keys: - customer_name (string)- order_id (string)- issue_type (one of: "shipping", "product_quality", "billing",  "returns", "other")- urgency (one of: "low", "medium", "high")- requested_action (string)- affected_product (string)- escalation_history (any prior contact about this issue, if mentioned) 

Email:---Hi there, I'm writing about order #FT-2289334 from last Tuesday. The Cascadehiking boots I received are NOT the size 11 I ordered — they'reclearly size 10 (I can see the label inside). I have a guided trekbooked in 5 days and I genuinely don't know what to do. I've beena customer for years and this is the first time something likethis has happened. Can you sort this out urgently? I'd prefer a same-day exchange ifat all possible. I'm in Manchester. Margaret W.--- Return only the JSON object. No commentary, no markdown code fences.

O que observar

Três coisas. Primeiro, se o modelo adere ao esquema JSON solicitado sem invenção. Segundo, como o modelo lida com o campo que não existe na fonte (escalation_history — a cliente não menciona contato prévio sobre este problema) — ele admite ausência, ou fabrica algo plausível? Terceiro, se o modelo produz comentário adicional fora do JSON, exigindo pós-processamento downstream para remover o invólucro. O campo de urgência também merece atenção: “5 dias” não é imediato, mas a cliente está claramente ansiosa, o que deixa espaço para interpretação.

O que as equipes que executam isto consistentemente relatam

GPT-5.5. Normalmente produz JSON limpo na primeira tentativa. Aderência ao esquema é forte; todo campo solicitado está presente, e o formato é analisável sem pré-processamento. Para campos ausentes, o GPT-5.5 tende a retornar um null explícito. Geralmente não envolve o JSON em cercas de código do Markdown nem inclui explicação em prosa, o que torna trivial o parsing downstream. Em decisões interpretativas ambíguas como a classificação de urgência aqui, o GPT-5.5 tende a ser mais conservador que os outros dois — onde Claude e Gemini podem classificar o tíquete como “high” com base no tom emocional da cliente, o GPT-5.5 frequentemente ancora na janela concreta de 5 dias e escolhe “medium”.

Claude Sonnet 4.6. Também produz JSON limpo, e costuma ser o mais preciso dos três ao seguir o esquema solicitado. Onde o GPT-5.5 deixa um campo ausente como null, o Claude frequentemente adiciona campos não solicitados sinalizando problemas de qualidade de dados — uma chave “notes” ou “data_quality_notes” que não foi pedida, mas contém informações de fato úteis. Esse campo extra é útil para revisores humanos, mas causa falhas se o seu analisador downstream for estrito quanto ao esquema. Este é um padrão recorrente com o Claude: alta qualidade, mas às vezes mais minucioso do que o pedido, exigindo instruções explícitas no prompt para restringir.

Gemini 3.1 Pro. Costuma produzir a saída mais econômica dos três. Todos os campos solicitados, nenhum campo extra, nenhuma prosa ao redor. Aderência ao esquema exatamente como pedido. Uma peculiaridade que vale saber: para campos ausentes, o Gemini tende a retornar uma string vazia em vez de null. Analisadores JSON estritos que distinguem entre esses valores vão detectar a diferença; analisadores frouxos não. O comportamento é consistente o suficiente entre execuções para parecer uma preferência do modelo, não um artefato.

O que isso lhe diz

Todos os três modelos conseguem fazer extração estruturada. As diferenças estão na margem comportamental em torno do esquema solicitado. Se o seu sistema downstream é estrito quanto ao esquema e trata campos extras como erros, Gemini 3.1 Pro e GPT-5.5 são escolhas mais seguras. Se você quer que o modelo evidencie problemas de qualidade de dados sem ser solicitado, Claude Sonnet 4.6 é mais útil. Nada disso aparece em um benchmark.

Prompt 2: Uma tarefa de planejamento com raciocínio pesado

Este prompt pede que os modelos planejem uma investigação de múltiplas etapas: uma questão de pesquisa com três restrições implícitas que um modelo cuidadoso deve identificar antes de sequenciar o trabalho. O tipo de tarefa que uma aplicação orientada a agentes delegaria a um LLM como a etapa de planejamento antes de invocar quaisquer ferramentas.

O prompt

I'm trying to answer this research question for my team: "Is our customer churn rate higher among users who haven't usedfeature X in the last 30 days?" Produce a plan for how to investigate this. The plan should:- Identify the steps required- Sequence them with dependencies- Be actionable for a data analyst on my team Return the plan in clear, structured form.

As restrições implícitas que valem observar: a pergunta nunca define o que “churn” significa (fechamento de conta? nenhum login? nenhuma compra?), não especifica como controlar variáveis de confusão (usuários de baixo engajamento dão churn por muitos motivos não relacionados ao recurso X) e não estabelece um grupo de comparação de referência. Um planejador cuidadoso deve evidenciar as três antes de produzir os passos.

O que observar

Se o modelo de fato raciocina sobre o problema ou produz uma sequência plausível que não se sustenta ao ser examinada. Se identifica as restrições implícitas sem que lhe sejam apontadas. E se as dependências entre os passos estão corretas — um plano que parece bom, mas tem a etapa três dependendo de um resultado que a etapa cinco produziria, é inútil na prática.

O que as equipes que executam isto consistentemente relatam

GPT-5.5. Normalmente produz o plano operacionalmente mais utilizável. O raciocínio tende a ser visível — o GPT-5.5 enumera suas suposições sobre as restrições implícitas (definição de churn, grupo de controle, variáveis de confusão) antes de expor os passos, o que facilita ver onde sua interpretação difere do que se pretendia. Dependências entre passos são identificadas e rotuladas de forma confiável. A saída frequentemente inclui uma seção destacando quais passos podem ser paralelizados, o que não foi solicitado, mas agrega valor genuíno. Este é o tipo de tarefa em que o treinamento para uso de ferramentas e comportamentos de agente do GPT-5.5 aparece — o planejamento é moldado pela suposição de que a execução downstream virá na sequência.

Claude Sonnet 4.6. Normalmente produz o plano mais reflexivo, no sentido literal — o plano do Claude frequentemente inclui considerações que os outros dois modelos não trazem. Em uma pergunta como esta, o Claude provavelmente vai apontar a questão metodológica de correlação vs causalidade, notar que “não usar o recurso X” pode ser um sintoma de churn, não uma causa, e identificar explicitamente restrições que não foram tornadas explícitas, mas que um analista cuidadoso deveria notar. O lado negativo: o plano pode ser mais longo do que o necessário, e etapas individuais às vezes superengenheiradas para a pergunta de fato. O padrão é consistente com o comportamento do Claude em outros contextos — cuidado em nível de especialista, às vezes mais do que a tarefa requer.

Gemini 3.1 Pro. Normalmente produz o plano mais claramente estruturado, com o grafo de dependências mais limpo. A qualidade do raciocínio é alta — o Gemini identifica de forma confiável as restrições implícitas, decompõe o problema em uma sequência defensável e produz instruções passo a passo que realmente seriam executáveis. A ressalva: o plano pode soar um tanto mecânico. Faz o trabalho, mas tende a não evidenciar as sutilezas metodológicas que o Claude levanta, nem os insights de paralelização que o GPT-5.5 inclui. Isso combina com o padrão mais amplo do Gemini — forte em qualidade de raciocínio, mais operário nas decisões ao redor.

O que isso lhe diz

A qualidade do raciocínio nesta tarefa é alta em todos os três modelos. As diferenças estão no comportamento ao redor — o que o modelo adiciona além do pedido literal. O GPT-5.5 adiciona pragmatismo operacional (paralelização, dicas de execução). O Claude adiciona cuidado de nível especialista (metodologia, casos de borda, nuance estatística). O Gemini adiciona clareza e economia. Nenhuma dessas é uma escolha errada. Qual se ajusta à sua aplicação depende do que você quer que o modelo faça quando terminar a tarefa que você pediu.

Prompt 3: Geração de código com restrições específicas

Este prompt pede que os modelos implementem uma função pequena, porém não trivial: uma função Python que recebe uma lista de eventos com carimbo de data e hora e retorna o maior intervalo entre eventos consecutivos, lidando com quatro casos de borda. As restrições são explícitas; a intenção é testar geração de código sob restrições, não teto de capacidade — todo modelo consegue escrever essa função. O que varia é como lidam com as restrições.

O prompt

Write a Python function that takes a list of timestamped events andreturns the longest gap (in seconds) between consecutive events. Requirements:- Function signature: longest_gap(events: list[datetime]) -> float- Handle these edge cases:  1. Empty list (return 0.0 or raise — your choice, but be consistent)  2. Single event  3. Duplicate timestamps  4. Unsorted input- Use only the standard library- Include type hints- Return just the function. No tests or usage examples.

O que observar

Se o modelo aborda os quatro casos de borda ou ignora silenciosamente alguns. Se as anotações de tipo são precisas ou apenas boilerplate. Se a implementação escolhe um algoritmo defensável (ordenar e varrer) ou algo exótico. E se o modelo respeita a restrição “sem testes, sem exemplos de uso” no final do prompt — este é o tipo de instrução tardia que modelos com forte seguimento de instruções vão honrar e modelos mais fracos vão violar discretamente.

O que as equipes que executam isto consistentemente relatam

GPT-5.5. Normalmente produz o código mais minuciosamente engenheirado. Todos os quatro casos de borda tratados com ramificações explícitas, anotações de tipo precisas (muitas vezes incluindo Optional ou Union para valores de retorno de casos de borda) e uma docstring com exemplos. A implementação geralmente escolhe o algoritmo óbvio — ordenar, varrer, rastrear o maior intervalo — e está correta. Vale saber: o GPT-5.5 frequentemente inclui testes unitários ou exemplos de uso mesmo quando o prompt pede explicitamente apenas a função. Este é o trade-off com modelos operacionalmente pragmáticos — eles adicionam o que acham que você vai precisar, mesmo quando você pede para não adicionar.

Claude Sonnet 4.6. Normalmente produz o código mais legível. A função é concisa, casos de borda tratados com um padrão limpo de cláusulas de guarda no topo, anotações de tipo precisas e mínimas. O Claude frequentemente inclui um comentário ponderado explicando uma decisão que o prompt deixou em aberto — por exemplo, sobre timestamps duplicados, tratá-los como intervalos de comprimento zero e explicar por quê, o que é uma decisão defensável que o prompt não especificou. O Claude tende a respeitar a restrição “sem testes” de forma mais confiável que o GPT-5.5. A função em si é a mais manutenível dos três. Consistente com a reputação do Claude para qualidade de código: limpo, idiomático, com toque de especialista.

Gemini 3.1 Pro. Normalmente produz o código mais econômico dos três. A função está correta, casos de borda tratados, implementação a mais curta. A docstring costuma ter uma única linha. As anotações de tipo estão presentes e corretas. A solução do Gemini raramente inclui testes ou comentários extensos, e não superengenheira — exatamente o que o prompt pediu. Para uma pessoa desenvolvedora que quer uma função funcionando e pretende adicionar testes separadamente, este é o caminho mais direto. Para quem quer que o modelo faça o trabalho ao redor também, os outros dois adicionam mais (quer você tenha pedido ou não).

O que isso lhe diz

Os três modelos conseguem escrever a função. A diferença comportamental está em quanto trabalho ao redor cada modelo faz além do pedido literal — e quão bem cada um respeita instruções explícitas do tipo “não adicione X”. O GPT-5.5 pende para a minúcia, mesmo quando a minúcia foi dispensada no prompt. O Claude pende para a qualidade artesanal (código legível, comentários ponderados sobre decisões). O Gemini pende para a economia (fazer exatamente o que foi pedido, nada além). Para workflows orientados a agentes em que a saída do modelo vai direto para uma base de código de produção, o comportamento desejado depende do que o seu processo de revisão downstream espera — e de quão estritamente você precisa que instruções negativas sejam seguidas.

Os padrões que emergem

Ao longo dos três prompts acima, três padrões comportamentais consistentes emergem de comparações e relatos de desenvolvedores publicados ao longo de 2026. Estes não são claims de capacidade — todo modelo lida com toda tarefa em alto nível. São tendências, o tipo de coisa que você só vê quando equipes observam o mesmo modelo lidar com dezenas de prompts. Rode os prompts acima na sua própria configuração e você verá os mesmos padrões; o artigo existe para dar o arcabouço para reconhecer o que você está vendo quando fizer isso.

Uma ressalva importante. Esses padrões são tendências, não regras. Cada modelo pode ser direcionado a qualquer um desses comportamentos com prompting apropriado — um system prompt suficientemente detalhado fará o Gemini adicionar testes, ou restringirá o Claude ao mínimo necessário, ou fará o GPT-5.5 pular os testes unitários. O ponto é o que cada modelo faz por padrão, antes de você começar a direcioná-lo. O comportamento padrão é o que você terá em produção a menos que ativamente faça prompting contra ele.

Como testar na sua própria carga de trabalho

O exercício acima é replicável em qualquer workload — e deveria ser. Pontuações de benchmarks são úteis como primeiro filtro, mas os padrões de comportamento do modelo que importam para a sua aplicação específica só são visíveis quando você observa os modelos lidando com seus prompts específicos.

Um guia prático para rodar o exercício no seu próprio tráfego:

1. Escolha três categorias de prompt representativas. Não três prompts aleatórios — três categorias que abranjam seu workload. A maioria dos sistemas de produção pode ser decomposta em um punhado de tipos de prompt (extração, classificação, geração, raciocínio, código, sumarização). Escolha as categorias que respondem pela maior parte do seu tráfego.
2. Selecione 20–30 exemplos por categoria. Idealmente do tráfego real. Anonimize quando necessário. O ponto é que os prompts devem se parecer com o que sua aplicação realmente vê, não com perguntas de benchmark. Vinte exemplos por categoria bastam para ver padrões; trinta bastam para ter confiança.
3. Rode-os por um único endpoint, em todos os modelos. Um endpoint agregador compatível com OpenAI torna isso dramaticamente mais rápido do que usar o SDK específico de cada modelo. O código no início deste artigo é toda a configuração. A mesma temperatura, os mesmos parâmetros, o mesmo prompt — as diferenças na saída são as diferenças entre modelos.
4. Avalie qualitativamente antes de quantitativamente. Examine os outputs primeiro. Os padrões comportamentais geralmente ficam óbvios na primeira dúzia de prompts. Quando você tiver uma hipótese sobre como cada modelo se comporta no seu workload, aí sim construa um critério para avaliar — mas a hipótese nasce da observação, não de um template de avaliação prévio.
5. Preste atenção ao que o modelo adiciona. A pergunta do benchmark é se o modelo acerta a resposta. A pergunta comportamental é o que mais o modelo faz. Ele adiciona testes? Explica seu raciocínio? Levanta preocupações? Produz campos extras que você não pediu? É aqui que vivem as diferenças entre modelos.
6. Escolha o modelo que combina com seu padrão downstream. Se seu processo downstream é automatizado, você quer um modelo cujo comportamento padrão produza saída limpa e analisável. Se seu processo downstream é revisão humana, você quer um modelo cujo comportamento padrão adicione o tipo de julgamento que um revisor humano gostaria de ver. A resposta certa depende do que vem depois do modelo.

Conclusão

A escolha entre GPT-5.5, Claude Sonnet 4.6 e Gemini 3.1 Pro não é sobre qual modelo é melhor. É sobre qual modelo se ajusta ao formato do seu workload — e esse formato é algo que benchmarks não conseguem ver. O exercício acima é replicável em uma tarde se você tiver os prompts selecionados; o valor de fazê-lo é que você para de supor e passa a observar.

Para as equipes que forem rodar o exercício por conta própria: a configuração mais fácil é um único endpoint compatível com OpenAI que exponha os três modelos atrás de uma credencial. CometAPI é um caminho; você aponta seu SDK OpenAI existente para uma base URL diferente e o parâmetro de modelo vira a variável.

Benchmarks dizem o que um modelo pode fazer. Padrões de comportamento dizem o que um modelo fará, por padrão, nos seus prompts. A primeira resposta é publicada. A segunda você precisa observar por conta própria. Vinte prompts por categoria, uma tarde, e você terá uma resposta que nenhum ranking jamais produzirá.

Pronto para integrar com confiabilidade? Vá até a CometAPI e a documentação da API para acesso integrado ao Claude Fable 5 ao lado de outros modelos de fronteira, faturamento unificado e confiabilidade de nível empresarial. Cadastre-se hoje e comece com créditos generosos para novos usuários — seu próximo projeto inovador espera por você.