Meu Agente de IA Criou uma Ferramenta de Benchmarking para os Meus Agentes de IA

Publicado em
11 agosto 2026
Atualizado em
9 novembro 2026
Por
Jacob Lloyd — escrito com ajuda de IA, depois do projeto
Tempo de leitura
27 min de leitura

Em termos simples: O nosso agente de codificação baseado em IA escreveu o bench-llm, um único arquivo Python que testa a velocidade de um modelo local e se ele consegue executar tarefas simples. Ele ainda funciona e pode ser baixado gratuitamente. Porém, em duas semanas o teste tornou-se muito fácil; por isso, substituímos o bench-llm pelo CrucibleForge, uma ferramenta gratuita mais completa que faz 276 perguntas e executa o código gerado pelo modelo para verificar seu funcionamento.

Em 11 de agosto de 2026, pedimos ao nosso agente de programação uma ferramenta que avaliasse os modelos locais em nosso conjunto de agentes. Ele retornou com o bench-llm: 1.660 linhas de código Python que medem a velocidade de execução no LM Studio, executam o código gerado pelo modelo e verificam se este consegue lidar com uma pequena tarefa de agente. Em duas semanas, todos os modelos que nos interessavam obtiveram nota 5/5 nesse teste; por isso, reconstruímos a ferramenta como CrucibleForge: até outubro de 2026, conta com 276 casos de teste, sendo 166 deles considerados difíceis. O código é de código aberto no GitHub. Esta página descreve ambas as ferramentas. Use o bench-llm para obter rapidamente uma avaliação inicial de um modelo; use o CrucibleForge quando precisar classificar modelos que já tenham passado nos testes mais fáceis.

Resumo rápido

  • bench-llm: um único arquivo Python, disponível gratuitamente para download. Ele testa a Velocidade (tempo até o primeiro token ser gerado, tokens/segundo), a Capacidade do modelo (5 testes: código, lógica, JSON, instruções e resumo) e sua aptidão como agente (3 verificações em uma tarefa simples). Requer Python 3.8+, pip install openai requests e LM Studio.
  • Motivo da descontinuação: os 5 testes de capacidade e as 3 verificações de aptidão deixam de ser úteis para diferenciar modelos, uma vez que os bons modelos passam em todos eles.
  • CrucibleForge 3.6: 276 casos de teste, sendo 166 difíceis. O código gerado pelo modelo é executado em um ambiente isolado e avaliado com base no resultado. Funciona com qualquer endpoint compatível com a OpenAI, possui uma interface web e agora pode ser executado via Docker ou no Windows. Licença MIT; github.com/LaserLloyd/CrucibleForge.
  • O que mostra o quadro de classificação: em 08/11/2026, o Kimi K3.1 Pro obteve a maior pontuação (19,3 de 20). Porém, os testes realizados indicaram que todos os 26 modelos estavam empatados. O MiniMax M3 recebeu sua primeira avaliação (14,6; subindo para 15,5 após contabilizar as reexecuções), com custo médio de US$ 0,57 por execução; o custo total para gerar todo o quadro foi de US$ 68,21.

Registro de alterações: 26/08/2026 – O bench-llm foi descontinuado e seus resultados foram transferidos para as novas ferramentas. 16/09/2026 – A seção sobre o CrucibleForge foi reescrita; o quadro de classificação foi reconstruído a partir dos arquivos de execução salvos, e a capa da página foi redesenhada. 19/10/2026 – Atualização da seção do CrucibleForge para a versão 3.6.0 (novidades): instalação, benchmark de um único comando e suporte ao Docker. 02/11/2026 – O quadro de classificação foi reconstruído com base na execução de 02/11/2026 (versão 4.0.0). 09/11/2026 – O quadro de modelos de nível difícil foi atualizado com os resultados da execução de 08/11/2026 (versão 4.1.0): agora há 26 modelos avaliados, o custo por execução está listado e o MiniMax M3 recebeu sua primeira pontuação.

O que você obtém no final

Um único comando executado em um modelo gera o seguinte resultado (exemplo de execução, resumido):

$ bench-llm gemma-4-31b-it

  bench-llm — Benchmarking: gemma-4-31b-it
  GGUF Size:     16.5 GB     Quant: Q4_K_M

  ⚡ SPEED BENCHMARKS
    short_50    TPS: mean=84.2   TTFT: mean=0.231s
    medium_200  TPS: mean=85.7   TTFT: mean=0.312s
    long_800    TPS: mean=82.1   TTFT: mean=0.541s
  🔍 Validating speed plausibility...  Confidence: HIGH

  🧠 ABILITY TESTS
    Code Generation (median_of_list)... PASS
    Logic Puzzle (Pet Ownership)....... PASS
    JSON Compliance.................... PASS
    Instruction Following.............. PASS
    Summarization (Key Facts).......... FAIL
    Ability Score: 4/5

  🤖 AGENT FITNESS TESTS
    Task Acknowledgment / Format Adherence / Conciseness: PASS
    Agent Fitness Score: 3/3

  📄 Results saved: ~/benchmarks/gemma-4-31b-it-2026-08-11.json

O arquivo JSON contém todos os tempos de processamento brutos, todas as respostas do modelo e um resumo. Você pode repassá-lo ao seu agente e perguntar: “Qual dos nossos modelos deve lidar com o processamento em massa de JSON?”

O que os testes do bench-llm avaliam

Velocidade

O teste envia três comprimentos de prompt (cerca de 50, 200 e 800 caracteres), realiza rodadas de aquecimento e, em seguida, mede três aspectos. O TTFT (tempo até o primeiro token) indica quanto tempo você espera para que o texto apareça; valores acima de 500 ms são considerados lentos em um chat. O Throughput (tokens/segundo) mede a velocidade com que o modelo começa a gerar texto após o início do processamento. Já o Prefill T/s avalia a rapidez com que o modelo lê o seu prompt.

Também é feita uma verificação de plausibilidade em relação aos limites de hardware conhecidos. Se um modelo de 30 GB afirmar alcançar 200 T/s numa placa 7900 XTX, o bench-llm sinaliza esse valor como suspeito, pois provavelmente a decodificação especulativa ou um cache já aquecido distorceram os resultados.

Habilidade

  • Geração de código: escreva median_of_list(numbers) garantindo que todos os casos extremos sejam tratados. O bench-llm executa a função em seis casos de teste, em vez de apenas ler o texto.
  • Quebra-cabeça lógico: um enigma envolvendo quatro pessoas e seus animais de estimação. O verificador extrai todas as quatro atribuições da resposta do modelo.
  • Conformidade com JSON: retorne um objeto contendo chaves exatas. Esse é o mínimo necessário para que um modelo possa ser usado em chamadas de ferramentas.
  • Seguimento de instruções: liste os números de 1 a 10, marque os pares e some-os. Os cálculos são simples; o formato da resposta é o que importa no teste.
  • Resumo de texto: condense um parágrafo complexo mantendo seis informações específicas. A maioria dos modelos acaba omitindo pelo menos uma delas.

Aptidão para agentes

O modelo recebe uma tarefa realista para agentes: procurar linhas com erros no syslog, agrupá-las por serviço e retornar um relatório em JSON. Três verificações avaliam essa única resposta:

  • Acknowledgment da tarefa: o modelo descreve uma abordagem e menciona o que não consegue fazer? Um modelo que inventa linhas de syslog falha nesse teste.
  • Adesão ao formato: há um array services, um inteiro total_errors e uma string scan_period na resposta?
  • Concisão: relação entre o tamanho da saída e do input. Uma resposta de 20.000 caracteres para um prompt de 1.300 caracteres é marcada como “VERBOSE”, pois um agente que fala demais consome rapidamente sua janela de contexto a cada interação.

Como foi construído

O nosso pedido ao agente de codificação foi uma única frase: “precisamos de uma ferramenta que faça benchmarking de modelos locais no LM Studio, testando sua velocidade e capacidades, e gerando resultados em formato JSON e em tabela.” Ele desenvolveu a ferramenta em quatro etapas, numa única tarde: testes de velocidade utilizando a API de streaming compatível com OpenAI do LM Studio; depois, testes de capacidades do modelo; em seguida, implementação das funcionalidades solicitadas; e por fim, ajustes finais (como localizar o arquivo GGUF no disco, verificar a plausibilidade dos resultados, além dos parâmetros --quick, --list e --check). O agente escreveu cada linha de código. A nossa parte foi executar a ferramenta em modelos reais e fornecer feedback. A verificação de plausibilidade existe porque informamos ao agente que um determinado valor de throughput era impossível para um modelo de 123 bilhões de parâmetros.

Escolhas de design que valem a pena copiar para as suas próprias ferramentas:

  • Use streaming, não polling. O cronometragem por token é a única forma de obter um valor real do tempo de resposta inicial (TTFT).
  • Execute o código. Um código que parece correto, mas não roda, deve ser considerado um fracasso, não um sucesso.
  • Extraia a resposta antes de verificá-la. Os mecanismos de verificação removem os textos introdutórios como “Claro! Aqui está a sua resposta:”. Dessa forma, o teste avalia apenas o conteúdo, e não o preâmbulo.
  • Inicie cada execução com uma GPU vazia. Caso contrário, o cache do modelo anterior distorce os valores de TTFT. A maneira como o bench-llm faz isso é o primeiro “pequeno truque” a ser observado.

Configuração

# 1. Install both dependencies (requests reads LM Studio's model metadata;
#    without it every model shows as "not found")
pip install openai requests

# 2. Start LM Studio with at least one model; it listens on localhost:1234

# 3. Run it
./bench-llm --list                         # what's available
./bench-llm gemma-4-31b-it --quick         # smoke test
./bench-llm gemma-4-31b-it                 # full benchmark

Não há arquivos de configuração nem banco de dados. O LM Studio aceita qualquer string como chave de API. Os resultados são salvos em ~/benchmarks/. Copie o script para uma pasta que esteja no seu PATH se quiser executá-lo de qualquer lugar.

Armadilhas comuns

  • O script encerra o llama-server. Para iniciar uma nova execução, ele executa pkill -f llama-server e aguarda que o LM Studio informe que não há modelos carregados. Qualquer outro processo llama-server na máquina também é encerrado. Não execute este script em uma máquina que hospede outros serviços, ou remova essa etapa.
  • O teste de codificação executa a saída do modelo usando exec(). Ele utiliza um namespace novo, que não é um sandbox. Execute-o como um usuário sem nada a perder, ou pule os testes de capacidade usando --speed-only.
  • Os modelos de raciocínio parecem lentos. O TTFT conta o primeiro token de qualquer tipo, incluindo os tokens de pensamento. O JSON divide esse valor em ttft_reasoning_s e ttft_content_s.
  • Uma pontuação 4/5, com apenas o teste de resumo falhando, é um resultado excelente. Quase todos os modelos deixam de capturar pelo menos um fato importante.
  • Uma execução completa leva de 2 a 5 minutos por modelo. Use --quick para comparar vários modelos, e execute o conjunto completo apenas nos finalistas.
  • O LM Studio deve já estar em execução. O bench-llm se conecta ao localhost:1234, mas não inicia nada por conta própria.

Resultados: modelos base no nosso “rig” e no mini PC

Esses números vêm do conjunto de testes intermediário que sucedeu o bench-llm (mesmo método de medição de velocidade, mais testes; relatório de 18/08/2026). O “rig” é um computador sem monitor equipado com 2× RTX 5090 e 2× RTX 3090. A “APU” é a GPU integrada do mini PC (quando este ainda executava um servidor de modelos locais). Compare as velocidades apenas dentro de cada dispositivo. As colunas “Code”, “Tools”, “Instruct” e “Reason” indicam as taxas de sucesso nos testes.

ModeloDispositivoGeração tok/sTTFTCodeToolsInstructReason
Gemma 4 26B-A4B (QAT, Q4)rig229,0110 ms88%100%50%95%
Nemotron 3 Nano 4B (Q8)APU18,5175 ms92%70%94%95%
Gemma 4 12BAPU10,1633 ms————

O modelo Gemma 4 26B do tipo “mixture-of-experts” (com 4B de parâmetros ativos) é o principal modelo utilizado no “rig”: gera 229 T/s, leva 110 ms para produzir o primeiro token e possui uma taxa de sucesso perfeita na execução de comandos. Sua fraqueza está no seguimento de instruções, algo essencial para um loop de agente não supervisionado. O modelo Nemotron 3 Nano 4B, rodando na APU do mini PC, segue melhor as instruções (94% contra 50%). Porém, é cerca de doze vezes mais lento (18,5 vs 229 T/s) e opera em um dispositivo diferente. Escolha o modelo com base na coluna que melhor se adapta à sua carga de trabalho, e não apenas pelo número mais alto de geração de tokens.

O que o substituiu: CrucibleForge

O bench-llm “morreu de sucesso”. Cinco testes de capacidade são suficientes para criar um bom detector de fumaça, mas insuficientes como sistema de classificação: quando todos os modelos obtêm pontuação máxima, a ferramenta não tem mais nada a dizer. O CrucibleForge é a reescrita do sistema original. Atualmente, possui cerca de 12.000 linhas de código Python; sua regra principal é que uma pergunta difícil deve ser igualmente fácil de avaliar.

  • 166 casos difíceis. Problemas matemáticos de competição com respostas inteiras, quebra-cabeças lógicos cujas soluções são únicas, além de problemas de programação cujos testes exigem um nível mínimo de complexidade (por exemplo, um algoritmo de contagem de inversões com complexidade O(n²) acaba por exceder o tempo limite). Há também situações que testam o uso de ferramentas, injeção de prompts e recuperação de contexto em textos longos (de 12k a 24k tokens), além de instruções com múltiplas restrições.
  • O código é avaliado através da sua execução em um ambiente isolado bwrap sem conexão à rede, com sistema somente leitura e limite de 15 segundos. Para ser aprovado, o programa precisa exibir uma string específica na saída padrão; assim, não é possível simular sucesso simplesmente retornando zero. Sem bwrap (o que acontece sempre no macOS e Windows), o sistema se recusa a executar código de modelos, a menos que seja informado o parâmetro --allow-unsandboxed.
  • As respostas em texto livre contam com uma resposta de referência. O modelo juiz tem acesso à resposta correta e decide apenas se a resposta dada tem o mesmo significado. Qualquer modelo capaz de seguir instruções consegue realizar essa tarefa; assim, o modelo juiz deixa de ser o ponto fraco do sistema.
  • Qualquer endpoint compatível com OpenAI. LM Studio, Ollama, llama.cpp, vLLM, DeepSeek, OpenRouter e outros. Os modelos hospedados processam os casos simultaneamente e informam o custo em tokens. As chaves de API são obtidas exclusivamente por meio de variáveis de ambiente.
  • O sistema recupera respostas que modelos de raciocínio perdem. Um modelo que dedica todo o seu “orçamento” de tokens ao raciocínio pode acabar retornando uma resposta vazia. O sistema detecta isso, repete o teste sem ativar o modo de raciocínio e registra a frequência desse ocorrido. O recurso recover reexecuta apenas esses casos a partir de uma execução anterior.
  • O CrucibleForge compartilha GPUs de forma justa. Em nosso equipamento StudioForge, cada execução “aluga” as placas de vídeo necessárias e devolve-as após concluir o trabalho. O antigo bench-llm utilizava o método pkill para resolver o mesmo problema, mas matando todos os modelos em execução.
  • Há uma interface web disponível em 127.0.0.1:8777 que permite selecionar modelos e categorias de testes, acompanhar os logs e visualizar qualquer caso reprovado: prompt, resposta, raciocínio do modelo e observações do juiz. Para funcionar fora do loopback, é necessário informar um token de autenticação.

Experimente

O caminho mais simples é usar o Docker, pois o contêiner também serve como sandbox para o código gerado pelos modelos. No Linux, com o Docker instalado:

git clone https://github.com/LaserLloyd/CrucibleForge.git && cd CrucibleForge
cp deploy/compose/.env.example deploy/compose/.env    # LLM_BASE_URL defaults to port 1234 on the Docker host
docker compose -f deploy/compose/compose.yml up -d
docker compose -f deploy/compose/compose.yml logs app | grep "GUI:"   # open the printed http://127.0.0.1:8777/?token=... URL

Ou então de forma nativa; no Linux isso proporciona isolamento através do bwrap para os casos de codificação:

sudo apt-get install -y bubblewrap
git clone https://github.com/LaserLloyd/CrucibleForge.git && cd CrucibleForge
uv sync --python 3.13
uv run crucibleforge config --init      # writes models.yaml; set base_url to your server's /v1
uv run crucibleforge status             # is the provider up? how many cases?
uv run crucibleforge all --models my-model --fresh --yes
uv run crucibleforge gui                # http://127.0.0.1:8777

Passe o parâmetro --python 3.13: numa máquina “limpa”, um simples comando uv sync pode selecionar uma versão mais nova do Python do que a suportada pelo projeto. No macOS e no Windows não há o bwrap; portanto, as execuções nativas exigem o uso de --allow-unsandboxed antes do subcomando (assim o código gerado pelos modelos roda normalmente), ou então é preciso usar o Docker Desktop. Caso seu servidor de modelos exija uma chave API, basta inserir o nome da variável em api_key_env, no arquivo models.yaml do respectivo provedor; a própria chave permanece no ambiente.

O comando all executa o único benchmark definido, profiles/bench.yaml: são 49 casos escolhidos como o conjunto mínimo capaz de diferenciar os modelos; depois disso ocorre a avaliação e a geração do painel de resultados. Cada modelo recebe duas pontuações, de 0 a 100. A categoria Coding é avaliada por sistemas determinísticos (programas, uso de ferramentas, seguimento de instruções, raciocínio e matemática). Já a categoria Chat analisa a escrita, o papel desempenhado pelo modelo e sua capacidade de ser direcionado; isso inclui categorias com conteúdo adulto que esta página não aborda. Os outros 276 casos permanecem no conjunto completo para execuções específicas usando --cases ou --categories. Os demais comandos disponíveis são run, judge, recover, report, pairwise, models, bench-all, import-openclaw e cases.

O painel da GUI web do CrucibleForge 3.6.0 com a configuração de exemplo fornecida: uma tabela de provedores onde lmstudio, ollama, llamacpp e openwebui aparecem como DOWN, enquanto os provedores hospedados estão marcados como UP, porém sem as variáveis de chave API definidas; um painel de avaliação que indica o juiz do benchmark e quatro candidatos alternativos; e uma tabela com 276 casos, sendo 166 considerados difíceis, organizados por categoria
A GUI num clone recém-criado, usando o arquivo models.yaml de exemplo e sem resultados ainda: mostra quais provedores respondem, qual juiz avalia o benchmark e o conjunto de casos (276 no total, 166 difíceis). Como nada estava rodando localmente, os status aparecem como DOWN.

O comando em que mais confiamos é aquele que verifica as próprias questões. Ele executa todas as soluções de referência na sandbox, recalcula cada resposta matemática por métodos brutos e reconstrói todo o contexto longo exigido. Este é o seu resultado numa cópia limpa da versão 3.6.0, em 19/10/2026:

$ uv run crucibleforge cases verify
276 cases checked, 0 with problems (36 reference solutions executed, 37 answers re-derived)

O conjunto de testes executa a mesma verificação; assim, uma questão problemática não pode simplesmente falhar silenciosamente para todos os modelos e ainda ser considerada “aprovada” num nível de dificuldade elevado.

O que há de novo na versão 3.6

O CrucibleForge 3.6.0 (18 de outubro de 2026) altera a forma como o projeto é instalado e executado, mas não o que ele mede. Nenhum caso, avaliador ou métrica foi modificado; os resultados marcados como 3.5.1 são considerados parte do mesmo conjunto de casos, portanto nada em um quadro de resultados existente se torna obsoleto.

  • Docker. Uma imagem somente leitura, sem necessidade de privilégios de root, com cerca de 190 MB. A interface gráfica fica disponível em 127.0.0.1:8777, enquanto seus arquivos models.yaml e os resultados ficam em um volume que permanece após atualizações. Dentro do contêiner, os casos de programação são executados sem bwrap, pois o próprio contêiner funciona como sandbox; ele ainda pode acessar a rede, então considere-o um ambiente onde código não confiável é executado.
  • Windows. O conjunto de testes é aprovado no Windows, e o sistema de CI também possui uma etapa para Windows. Uma limitação: o mecanismo que impede a execução simultânea de dois benchmarks não funciona no Windows; portanto, inicie apenas um por vez.
  • Autoteste da sandbox. Um mecanismo bwrap instalado, mas incapaz de isolar efetivamente o ambiente (dentro de um contêiner ou com namespaces de usuário bloqueados) é detectado antes do início da execução. Nesse caso, a execução é recusada (ou, com --allow-unsandboxed, ocorre sem sandbox e isso é informado previamente), em vez de gerar falhas em todos os casos de programação.
  • Chaves de API e mensagens de erro mais claras. O status indica quando um servidor responde com código 401 ou 403, além de informar qual variável deve ser configurada; isso é exatamente o que um gateway StudioForge 2.0 que utiliza chaves de API precisa.
  • Correção em 19/10/2026: o botão “Judge pending rows” da interface gráfica atribuía pontuação aos casos usando um avaliador alternativo cujos resultados não são considerados no quadro final; agora ele utiliza o avaliador padrão do benchmark, como sempre ocorria na linha de comando, e o painel de controle também identifica esse avaliador corretamente.

Atualização. De forma nativa, basta executar git pull && uv sync --python 3.13. Se o seu arquivo models.yaml direcionar o StudioForge para a porta 8080, altere-a para 1234: a porta 8080 é usada pelo painel do StudioForge, enquanto a API funciona na porta 1234. O arquivo models.yaml já existente nunca será sobrescrito automaticamente. No Docker, execute git pull e depois docker compose -f deploy/compose/compose.yml up -d --build; o volume de dados é mantido, e down -v é o único comando capaz de removê-lo.

Como é um relatório

report gera um arquivo Markdown e um arquivo JSON. Cada modelo recebe uma linha de resumo e uma linha por categoria, contendo as contagens brutas. Eis a linha por categoria do DeepSeek V4 Pro:

| Model        | Coding      | Math        | Tool use    | Instruction  | Reasoning    | Long-context |
| deepseek-pro | 89% (54/61) | 95% (21/22) | 94% (31/33) | 100% (31/31) | 100% (37/37) | 97% (29/30)  |

Cada falha é listada com seu respectivo motivo. Todas as sete falhas de codificação parecem-se com a primeira linha abaixo. A segunda linha representa um dos dois casos em que o modelo não conseguiu utilizar corretamente as ferramentas disponíveis:

- deepseek-pro [coding] CZ01-prime-census: TRUNCATED at 32768 tokens (32768 reasoning tokens); no code in response
- deepseek-pro [tooluse] TZ06-three-parallel-one-turn: 1 calls, expected 3

Essa é a parte útil do relatório. O modelo não escreveu código ruim; ele pensou até que o limite de 32.768 tokens foi atingido, sem nunca chegar a escrever nada. Um orçamento maior ou um esforço de raciocínio menor mudariam esse resultado. A simples taxa de sucesso, por si só, não revelaria isso.

Os modelos hospedados também têm um campo Custo de execução no relatório, que indica o preço de uma execução dos testes padrão (veja a documentação do MakoBench).

Resultados do nível difícil

Este é o quadro de resultados conforme estava em 09/11/2026, reconstruído a partir da execução de 08/11/2026 no pacote 4.1.0 e avaliado pelo modelo gemma-4-31B. A pontuação segue as regras descritas anteriormente: cada categoria tem nota máxima de 10 no teste padrão; a nota geral é sobre 20 pontos (soma das notas de Programação e Conversação). Uma categoria só ultrapassa a nota 10 após a liberação de um “pacote de desafios” — três questões mais difíceis, cada uma valendo 1 ponto, concedidas apenas após atingir 90% em todas as demais avaliações. A parte de Programação é determinística (funções, previsão e detecção de erros, uso de ferramentas); a parte de Conversação é subjetiva (atuação em papéis, diálogo, criatividade). O símbolo “±” após uma nota indica metade do intervalo de 90% obtido via método bootstrap; portanto, dois modelos cujos intervalos se sobrepõem são considerados empatados, não há hierarquia entre eles.

Classe indica a faixa geral em que a nota se enquadra (S: 16 ou mais; A: 13 a 15; B: 10 a 12). Linhas concluídas mostra a proporção de linhas cujas respostas foram geradas dentro do orçamento padrão — uma linha que esgotou o orçamento é considerada como falha; algumas ainda aguardam nova tentativa, portanto as notas podem sofrer alterações. Custo da execução representa o valor de uma execução padrão segundo os preços do provedor, apenas para geração de conteúdo; a avaliação é feita em nossos próprios recursos computacionais. O relatório também informa a velocidade média de geração, porém essa métrica só é comparável entre modelos rodando no mesmo host; como os modelos aqui usam máquinas de provedores diferentes, optamos por omiti-la.

Avaliação recente — e um empate em todo o quadro

  • Uma única execução, um único avaliador, um só dia. Todas as 26 linhas abaixo foram executadas e avaliadas em 08/11/2026, no pacote 4.1.0, com gemma-4-31B como avaliador.
  • O próprio teste de comparação não consegue diferenciar nenhum par de modelos. O intervalo de 90% de cada par adjacente contém zero; esses empates se estendem por todo o quadro, motivo pelo qual todas as 26 linhas recebem a mesma classificação. Os valores entre 19,3 e 11,3 devem ser vistos como estimativas pontuais, não como uma hierarquia.
  • MiniMax M3 finalmente obteve uma nota avaliada. No quadro anterior, recebia apenas uma nota em Programação, sem pontuação geral. Agora está em 14,6 ± 1,7; a coluna “Room” indica que, após novas execuções com orçamento maior, sua nota chegaria a 15,5 — ainda falta mais uma tentativa. Custando cerca de US$ 0,57 por execução, seu custo é um sétimo do valor pago pelo modelo melhor posicionado.

Nível difícil — quadro completo com 26 modelos

ModeloNota geralProgramaçãoConversaçãoClasseLinhas concluídasCusto da execução
Kimi K3.1 Pro19,3 ± 0,510,0 ± 0,19,3 ± 0,5S100%$4,07
Grok 4.719,2 ± 0,310,0 ± 0,19,2 ± 0,3S100%$3,91
Claude Opus 5.519,2 ± 0,510,0 ± 0,19,2 ± 0,5S100%$4,50
DeepSeek V4 Flash18,8 ± 0,811,2 ± 0,47,6 ± 0,6S92% (4 esgotaram orçamento)$0,14
Claude Sonnet 5.518,6 ± 0,410,0 ± 0,18,6 ± 0,4S100%$2,36
GPT-6.1 Terra17,9 ± 1,09,4 ± 0,68,5 ± 0,7S100%$0,63
DeepSeek V4 Pro17,8 ± 0,710,1 ± 0,57,7 ± 0,4S89% (5 esgotaram orçamento)$0,57
GPT-6 Luna17,7 ± 0,69,7 ± 0,28,0 ± 0,5S100%$0,08
Claude Opus 516,7 ± 1,48,3 ± 1,28,4 ± 0,4S100%$5,07
Claude Opus 4.816,3 ± 0,69,2 ± 0,57,1 ± 0,4S100%$4,37
Claude Fable 5.116,1 ± 0,97,7 ± 0,58,4 ± 0,7S100%$10,23
Claude Opus 4.716,1 ± 0,89,3 ± 0,66,8 ± 0,5S100%$4,75
Claude Fable 516,0 ± 1,97,5 ± 1,98,5 ± 0,6S100%$9,70
Claude Haiku 5.515,3 ± 1,19,2 ± 0,76,1 ± 0,9A100%$0,11
Claude Opus 4.615,3 ± 1,38,0 ± 1,37,3 ± 0,3A100%$3,38
Claude Sonnet 515,3 ± 0,98,8 ± 0,86,4 ± 0,4A100%$2,81
Claude Sonnet 4.614,6 ± 1,67,6 ± 1,47,0 ± 0,7A97% (1 esgotou orçamento)$2,98
MiniMax M2.5 Highspeed14,6 ± 0,88,3 ± 0,76,3 ± 0,4A100%~$0,63
MiniMax M314,6 ± 1,78,5 ± 0,86,0 ± 1,4A94% (2 esgotaram orçamento)~$0,57
Claude Opus 4.513,8 ± 1,47,1 ± 1,26,7 ± 0,7A100%$3,27*
MiniMax M3.1 Flash13,6 ± 1,78,0 ± 0,95,6 ± 1,4A94% (2 esgotaram orçamento)~$0,28
MiniMax M2.713,4 ± 1,76,7 ± 1,66,7 ± 0,5A100%~$0,30
MiniMax M2.7 Highspeed13,2 ± 1,27,6 ± 0,95,6 ± 0,8A100%~$0,62
Claude Sonnet 4.513,2 ± 1,16,4 ± 1,16,8 ± 0,4A100%$1,94*
MiniMax M2.512,2 ± 1,86,4 ± 1,65,8 ± 0,8B100%~$0,31
Claude Haiku 4.511,3 ± 1,25,7 ± 1,05,6 ± 0,6B100%$0,63*

Resumo de custos: uma execução padrão envolvendo todas as 26 linhas custou US$ 68,21 em tokens ao provedor, apenas para geração de conteúdo; a avaliação é feita em nossos próprios recursos computacionais. A categoria de conteúdo adulto, não abordada nesta página, possui preços distintos. Doze das 26 linhas custaram menos de um dólar no total — US$ 4,87 ao todo; os outros 14 modelos representam US$ 63,34 do total, sendo que os dois mais caros, Claude Fable 5.1 e Claude Fable 5, somam US$ 19,93 desse valor. Seis dos valores são estimativas baseadas na contagem de tokens, não em cobranças reais; três possuem asterisco pois algumas solicitações retornaram sem dados de uso, portanto o total real é ligeiramente superior.

O que não consta no quadro. Trinta e duas linhas são modelos ajustados por nós mesmos; o relatório marca todas como incompletas, pois suas execuções não cobriram todo o conjunto padrão de testes — por isso nenhuma possui nota geral nem classificação. Quatro deles falharam totalmente: três tiveram negada a concessão de GPU e um foi interrompido durante a execução. Oito modelos hospedados ainda aguardam avaliação: três têm vinte linhas que o avaliador ainda não pontuou; cinco foram rejeitados pelo provedor antes mesmo de rodarem. Todas as linhas acima ainda apresentam alguns resultados obtidos sob a escala anterior, pendentes de nova avaliação; assim, as notas podem sofrer pequenas alterações.

Os modelos hospedados trazem seus nomes comerciais. Vinte e quatro linhas misturam resultados do pacote 4.0.1 com esta execução no 4.1.0; DeepSeek V4 Flash e DeepSeek V4 Pro também incorporam dados do 3.9.0. O símbolo “~” indica que o custo foi estimado a partir da contagem de tokens segundo os preços listados; o asterisco significa que algumas solicitações retornaram sem informações de uso, podendo portanto ser inferior ao valor real. Quatro linhas pendentes trazem rótulos de registro com nomes de modelos descontinuados que este site não exibe.

Principais conclusões:

  • Nenhum modelo está à frente. Todo par adjacente no quadro apresenta um intervalo de 90% que contém zero; esses empates se estendem da primeira até a última linha, razão pela qual todas as 26 recebem a mesma classificação. Os valores 19,3 e 11,3 representam oito pontos de diferença no papel, porém são indistinguíveis nesta execução — trate a ordem como uma estimativa pontual.
  • O custo é o fator que os separa. Uma execução padrão das 26 linhas custou US$ 68,21. O DeepSeek V4 Flash gera 18,8 pontos por apenas US$ 0,14; já o Claude Fable 5.1 obtém 16,1 pontos por US$ 10,23 — cerca de 85 vezes menos pontos por dólar. Doze modelos custaram menos de um dólar cada, sendo que quatro deles alcançaram nota igual ou superior a 16.
  • A parte de Programação lidera o quadro; a de Conversação não. Apenas DeepSeek V4 Flash (11,2) e DeepSeek V4 Pro (10,1) ultrapassam a marca de 10 na avaliação de Programação; ambos desbloquearam os pacotes de desafios. Nenhum modelo chega a 10 em Conversação, onde o melhor resultado é 9,3 do Kimi K3.1 Pro. Para quem pretende integrar um modelo num agente, a coluna de Programação é a mais relevante.
  • O orçamento disponível funciona como filtro silencioso. Cinco linhas esgotaram seu limite — DeepSeek V4 Pro (5), DeepSeek V4 Flash (4), MiniMax M3 e MiniMax M3.1 Flash (2 cada) e Claude Sonnet 4.6 (1). No quadro, uma linha que ultrapassa o orçamento é considerada falha. Quando há nova execução possível, a coluna “Room” mostra a pontuação com esse fator incluído: MiniMax M3 atinge 15,5 e MiniMax M3.1 Flash chega a 14,5, ambos 0,9 pontos acima de suas notas originais; as pontuações do DeepSeek V4 Flash e do Claude Sonnet 4.6 ainda aguardam definição.
  • Os filtros dos provedores custam pontos reais. Quatro linhas tiveram respostas bloqueadas pelo filtro de conteúdo do provedor — Claude Fable 5 (6), Claude Opus 5 (2), Claude Fable 5.1 (2) e Claude Opus 5.5 (1); uma resposta bloqueada vale zero pontos. Cinco linhas ainda apresentam um resultado que o avaliador não conseguiu interpretar.

Download

O arquivo para download é o bench-llm, a versão original agora descontinuada; não se trata do CrucibleForge (que pode ser encontrado no GitHub). O pacote ZIP contém dois arquivos: bench-llm, o script com 1.660 linhas, e README.md, que traz instruções resumidas de configuração. Não há necessidade de compilar ou instalar nada além desses dois arquivos: basta descompactar e executar. Ambos os arquivos foram criados por um agente de IA e são licenciados sob a licença MIT. As dependências necessárias são openai e requests. Leia as observações importantes antes de executar o programa numa máquina que hospede outros serviços.

Relacionado: StudioForge (o servidor com GPU do qual esses modelos utilizam os recursos), Quanto realmente custam meus agentes de IA (explicando a importância da velocidade local), DeepSeek Harness (um agente de programação que utiliza esses modelos) e a pilha de agentes de IA local na qual eles operam.

Downloads

Gratuito para uso pessoal. Se isso te economizar uma tarde, o botão do café está logo ali.


← Mais de IA e LLM Local More MakoBench articles →