Mi agente de IA creó una herramienta de evaluación para mis agentes de IA

Categoría
IA y LLM Local
Publicado
11 agosto 2026
Actualizado
9 noviembre 2026
Por
Jacob Lloyd — escrito con ayuda de IA, después del proyecto
Tiempo de lectura
26 min de lectura

En palabras simples: Nuestro agente de programación con IA escribió bench-llm, un único archivo de Python que mide la velocidad de un modelo local y si puede realizar tareas sencillas. Sigue funcionando y es gratis de descargar. Se volvió demasiado fácil en dos semanas, así que lo reemplazamos por CrucibleForge, una herramienta gratuita más grande que plantea 276 preguntas y ejecuta el código que escribe el modelo para comprobarlo.

El 2026-08-11 pedimos a nuestro agente de programación una herramienta que evaluara los modelos locales de nuestro stack de agentes. Nos entregó bench-llm: 1.660 líneas de Python que miden la velocidad en LM Studio, ejecutan el código que escribe un modelo y comprueban si el modelo puede realizar una pequeña tarea de agente. En dos semanas, todos los modelos que nos importaban obtenían 5/5, así que lo reconstruimos como CrucibleForge: 276 casos a octubre de 2026, 166 de ellos difíciles, de código abierto en GitHub. Esta página cubre ambos. Use bench-llm para obtener un primer número de un modelo en cinco minutos. Use CrucibleForge cuando necesite clasificar modelos que todos superan las pruebas fáciles.

tl;dr

  • bench-llm: un único archivo de Python, descarga gratuita. Evalúa Velocidad (tiempo hasta el primer token, tokens/seg), Capacidad (5 pruebas: código, lógica, JSON, instrucciones, resumen) y Aptitud para agentes (3 comprobaciones en una tarea de syslog). Requiere Python 3.8+, pip install openai requests y LM Studio.
  • Por qué se retiró: 5 pruebas de capacidad y 3 comprobaciones de agente dejan de distinguir entre modelos una vez que los buenos modelos las superan todas.
  • CrucibleForge 3.6: 276 casos, 166 difíciles. El código se ejecuta en un sandbox y se califica por el resultado. Funciona con cualquier endpoint compatible con OpenAI, tiene una interfaz web y ahora se ejecuta en Docker y en Windows. Licencia MIT, github.com/LaserLloyd/CrucibleForge.
  • Qué muestra el tablero: Kimi K3.1 Pro tiene la puntuación más alta en el tablero del 2026-11-08 con 19,3 de 20, aunque la propia prueba pareada del tablero declara empatados a los 26 modelos; MiniMax M3 tiene por primera vez una puntuación evaluada (14,6, y 15,5 cuando cuentan sus re-ejecuciones) a unos $0,57 por ejecución, y el tablero completo costó $68,21.

Registro de cambios: 2026-08-26, bench-llm se retiró y los resultados se trasladaron a las suites sucesoras. 2026-09-16, se reescribió la sección de CrucibleForge, se reconstruyó la tabla de clasificación a partir de los archivos de ejecución guardados, se rediseñó la portada. 2026-10-19, se actualizó la sección de CrucibleForge para 3.6.0 (novedades): instalación actual, el benchmark con un solo comando, Docker. 2026-11-02, se reconstruyó el tablero de modelos a partir de la ejecución del 2026-11-02 (suite 4.0.0). 2026-11-09, se reconstruyó el tablero de nivel difícil a partir de la ejecución del 2026-11-08 (suite 4.1.0): 26 modelos evaluados, el costo de ejecución de nuevo en el tablero, MiniMax M3 puntuado por primera vez.

¿Qué obtienes al final?

Un único comando ejecutado contra un modelo genera lo siguiente (ejemplo de ejecución, recortado):

$ 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

El archivo JSON contiene todos los tiempos de ejecución, todas las respuestas del modelo y un resumen. Puedes entregárselo a tu agente y preguntarle: “¿cuál de nuestros modelos debería encargarse del procesamiento masivo de JSON?”

¿Qué pruebas realiza Bench-LLM?

Velocidad

Envía tres longitudes de prompts (aproximadamente 50, 200 y 800 caracteres), realiza ejecuciones de calentamiento y luego mide tres cosas. El TTFT (tiempo hasta el primer token) indica cuánto se espera hasta que aparezca el texto; más de 500 ms se percibe como lentitud en un chat. El Throughput (tokens/segundo) muestra la velocidad a la que escribe una vez iniciada la generación. El Prefill T/s indica cuán rápido lee el modelo el prompt.

También realiza una verificación de plausibilidad frente a los límites hardware conocidos. Si un modelo de 30 GB afirma alcanzar 200 T/s en una tarjeta 7900 XTX, Bench-LLM marca esa cifra como sospechosa, ya que es probable que el decodificado especulativo o un caché “caliente” hayan distorsionado el resultado.

Habilidad

  • Generación de código: escribir median_of_list(numbers) manejando los casos límite. Bench-LLM ejecuta la función con seis casos de prueba en lugar de limitarse a leer el texto.
  • Puzle lógico: un problema de asignación de mascotas entre cuatro personas. El verificador extrae las cuatro asignaciones del mensaje de respuesta.
  • Cumplimiento JSON: devolver un objeto con claves exactas. Este es el mínimo requerido para que un modelo pueda interactuar con herramientas externas.
  • Cumplimiento de instrucciones: listar los números del 1 al 10, marcar los pares y sumarlos. El cálculo matemático es sencillo; lo que se evalúa es el formato de la respuesta.
  • Resumen: condensar un párrafo denso manteniendo seis datos específicos. La mayoría de los modelos omiten al menos uno.

Aptitud como agente

Al modelo se le asigna una tarea realista para agentes: buscar líneas con ERROR en el syslog, agruparlas por servicio y devolver un informe en formato JSON. Tres verificaciones evalúan esa única respuesta:

  • Aceptación de la tarea: ¿describe el modelo un enfoque y menciona lo que no puede hacer? Un modelo que invente líneas de syslog fracasa en esta prueba.
  • Cumplimiento del formato: ¿existe el array services, el entero total_errors y la cadena scan_period?
  • Concisión: relación entre longitud de la respuesta y del prompt. Una respuesta de 20,000 caracteres para un prompt de 1,300 se marca como “VERBOSE”, ya que un agente prolijo agota su ventana de contexto en cada interacción.

Cómo se construyó

Nuestra instrucción para el agente de codificación fue una sola frase: “necesitamos una herramienta que haga benchmarking de modelos locales en LM Studio, mida su velocidad y capacidades, y genere resultados en formato JSON y una tabla”. El agente creó la herramienta en cuatro fases durante una sola tarde: primero realizó pruebas de velocidad mediante la API de streaming compatible con OpenAI que ofrece LM Studio; luego probó las capacidades del modelo; después ejecutó las tareas asignadas y finalmente realizó los ajustes necesarios (como localizar el archivo GGUF en el disco, verificar la plausibilidad de los resultados, y gestionar las opciones --quick, --list y --check). El agente escribió cada línea de código. Nuestra parte consistió en ejecutarlo con modelos reales y proporcionarle retroalimentación. La verificación de plausibilidad existe porque le indicamos al agente que un determinado valor de rendimiento era imposible para un modelo de 123 mil millones de parámetros.

Decisiones de diseño que merece la pena copiar en sus propias herramientas:

  • Utilice transmisión de datos en tiempo real, no consultas periódicas. Medir el tiempo por cada token es la única forma de obtener un valor preciso del TTFT.
  • Ejecute el código. Un código que parece correcto pero no se ejecuta debe considerarse un error, no un éxito.
  • Extraiga la respuesta antes de verificarla. Los mecanismos de verificación eliminan los prefacios como “¡Claro! Aquí tiene su respuesta:”. De este modo, la prueba evalúa el contenido en sí, no el texto introductorio.
  • Inicie cada ejecución con una GPU vacía. De lo contrario, el caché del modelo anterior distorsionaría los valores de TTFT. La forma en que bench-llm logra esto es el primer “truco” que mencionaremos a continuación.

Configuración

# 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

No hay archivos de configuración ni base de datos. LM Studio acepta cualquier cadena de texto como clave de API. Los resultados se guardan en ~/benchmarks/. Si desea ejecutar el script desde cualquier lugar, cópielo en una carpeta que esté incluida en su variable PATH.

Posibles problemas

  • Termina con llama-server. Al iniciar cada ejecución, limpia el entorno ejecutando pkill -f llama-server y espera a que LM Studio informe que no hay modelos cargados. Cualquier instancia de llama-server en la máquina también se detiene. No lo ejecute en un equipo que sirva otros servicios, o elimine ese paso.
  • La prueba de codificación ejecuta la salida del modelo mediante exec(). Utiliza un espacio de nombres nuevo, que no constituye un entorno aislado. Ejecútelo como un usuario sin nada que perder, o salte las pruebas de capacidades con --speed-only.
  • Los modelos de razonamiento parecen lentos. El valor TTFT cuenta el primer token de cualquier tipo, incluidos los tokens de razonamiento. El JSON lo divide en ttft_reasoning_s y ttft_content_s.
  • Una puntuación de 4/5, con solo la tarea de resumen fallando, es un resultado excelente. Casi todos los modelos omiten al menos un dato importante.
  • Una ejecución completa tarda entre 2 y 5 minutos por modelo. Utilice --quick para comparar varios modelos, y luego ejecute el conjunto completo de pruebas con los finalistas.
  • LM Studio debe estar ya en ejecución. bench-llm se conecta a localhost:1234 y no inicia nada por sí mismo.

Resultados: modelos base en nuestro “rig” y mini PC

Estas cifras provienen del conjunto de pruebas intermedio posterior a bench-llm (mismo método de medición, más pruebas; informe fechado el 18-08-2026). El “rig” es un equipo sin pantalla equipado con 2× RTX 5090 y 2× RTX 3090. La “APU” es la GPU integrada del mini PC (cuando aún ejecutaba un servidor de modelos local). Comparen las velocidades únicamente dentro de cada dispositivo. Los valores de “Code”, “Tools”, “Instruct” y “Reason” representan los porcentajes de éxito.

ModeloDispositivoGen 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————

El modelo Gemma 4 26B de tipo “mixture-of-experts” (con 4B de parámetros activos) es el caballo de batalla en el “rig”: alcanza 229 T/s, un tiempo de espera para el primer token de 110 ms y un rendimiento perfecto en la ejecución de herramientas. Su punto débil es el seguimiento de instrucciones, algo en lo que más depende un bucle de agente no supervisado. El modelo Nemotron 4B en el mini PC sigue mejor las instrucciones (94% frente a 50%). Sin embargo, es aproximadamente doce veces más lento (18.5 vs 229 T/s) y funciona en un dispositivo distinto. Elijan el modelo según la columna que más influya en su carga de trabajo, no únicamente por la cifra de velocidad más alta.

¿Qué lo reemplazó? CrucibleForge

bench-llm dejó de ser útil debido a su propio éxito: cinco pruebas de capacidad bastan para evaluar adecuadamente un modelo, pero también hacen que la herramienta no tenga nada más que decir cuando todos los modeles obtienen puntuaciones perfectas. CrucibleForge es la reescritura de dicha herramienta. Ahora consta de unas 12.000 líneas de código Python, y su principio fundamental es que una pregunta difícil debe seguir siendo fácil de calificar.

  • 166 casos difíciles. Problemas matemáticos de competición con respuestas numéricas enteras, cuadros lógicos con soluciones únicas y problemas de programación cuyas pruebas exigen un nivel determinado de complejidad (por ejemplo, un algoritmo de conteo de inversiones O(n²) supera el límite de tiempo permitido). También incluye casos que requieren uso de herramientas, inyección de prompts, recuperación de información en contextos largos de 12k–24k tokens e instrucciones con múltiples restricciones.
  • El código se califica ejecutándolo en un entorno aislado bwrap sin conexión a la red, con sistema de archivos de solo lectura y un límite de 15 segundos. Para ser aprobado, el programa debe imprimir una cadena específica en stdout; de este modo no puede simular éxito simplemente devolviendo un código de salida cero. Sin bwrap (situación habitual en macOS y Windows), la herramienta se niega a ejecutar el código del modelo a menos que se especifique --allow-unsandboxed.
  • Las respuestas en prosa cuentan con una respuesta de referencia. El modelo juez visualiza dicha respuesta y decide si la contestación del modelo transmite el mismo significado. Cualquier modelo capaz de seguir instrucciones puede realizar esa tarea, por lo que el modelo juez ya no constituye un punto débil en el sistema.
  • Cualquier endpoint compatible con OpenAI. LM Studio, Ollama, llama.cpp, vLLM, DeepSeek, OpenRouter y otros. Los modelos alojados procesan los casos de forma concurrente y reportan el coste en tokens. Las claves API se obtienen exclusivamente a través de variables de entorno.
  • Recupera respuestas que los modelos razonadores pierden. Un modelo capaz de razonar que agota su presupuesto de tokens termina devolviendo una respuesta vacía. El sistema lo detecta, vuelve a enviar el mismo prompt sin activar la capacidad de razonamiento y registra cuántas veces ocurre esto. recover reejecuta únicamente esos casos a partir de una ejecución previa.
  • Comparte las GPU de manera equitativa. En nuestro equipo StudioForge, cada ejecución solicita las tarjetas gráficas que necesita y las libera al finalizar. El comportamiento anterior de bench-llm, mediante pkill, consistía en matar todos los modelos activos para liberar recursos.
  • Interfaz web disponible en 127.0.0.1:8777: permite seleccionar modelos y categorías, visualizar el registro de ejecución y abrir cualquier caso fallido para consultar el prompt, la respuesta, el razonamiento del modelo y el comentario del juez. Para aceptar conexiones externas, se requiere un token; de lo contrario solo acepta tráfico local.

Pruébelo

La forma más sencilla es usar Docker, ya que el contenedor también sirve como entorno aislado para el código generado por los modelos. En Linux, con 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

O bien de forma nativa; en Linux esto proporciona el aislamiento mediante bwrap para los casos de codificación:

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

Pase el parámetro --python 3.13: en una máquina sin configuraciones especiales, simplemente ejecutar uv sync permite utilizar una versión de Python más reciente de la que el proyecto admite. En macOS y Windows no existe bwrap, por lo que las ejecuciones nativas requieren --allow-unsandboxed antes del subcomando (de este modo el código generado por el modelo se ejecuta bajo su control); alternativamente, puede usar Docker Desktop. Si su servidor de modelos necesita una clave API, indique el nombre de la variable en api_key_env dentro del proveedor correspondiente en el archivo models.yaml; la clave en sí se mantiene en el entorno.

all ejecuta el único conjunto de pruebas, definido en profiles/bench.yaml: 49 casos seleccionados como el conjunto mínimo capaz de diferenciar a los modelos; luego se procede a la evaluación y al cálculo de resultados. Cada modelo recibe dos puntuaciones, de 0 a 100. La categoría Coding se evalúa mediante sistemas deterministas (programas, uso de herramientas, seguimiento de instrucciones, razonamiento y matemáticas). La categoría Chat incluye evaluaciones de redacción, juego de roles y capacidad de orientación del modelo; también abarca categorías de contenido para adultos que esta página no detalla. Los otros 276 casos permanecen disponibles para ejecuciones específicas mediante --cases o --categories. Los demás comandos son run, judge, recover, report, pairwise, models, bench-all, import-openclaw y cases.

El panel de control web de CrucibleForge 3.6.0 con la configuración de ejemplo: una tabla de proveedores donde lmstudio, ollama, llamacpp y openwebui aparecen marcados como DOWN; los proveedores alojados se muestran como UP aunque no se hayan definido sus variables de clave API; un panel de evaluación que indica el juez asignado y cuatro candidatos alternativos; y una tabla con los 276 casos, de los cuales 166 son considerados difíciles, clasificados por categoría
La interfaz gráfica en una copia recién clonada, con el archivo models.yaml de ejemplo y sin resultados: muestra qué proveedores responden, qué juez evalúa los modelos y el conjunto de casos (276 en total, 166 difíciles). Como no se ejecutaba nada localmente, todos los proveedores aparecen marcados como DOWN.

El comando en el que más confiamos es el que verifica las propias preguntas. Este ejecuta todas las soluciones de referencia dentro del entorno aislado, vuelve a calcular cada respuesta matemática mediante métodos exhaustivos y reconstruye cada caso de contexto largo. Este es su resultado en una copia limpia de la versión 3.6.0, fechada el 19 de octubre de 2026:

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

El conjunto de pruebas realiza la misma verificación; por eso, una pregunta defectuosa no puede pasar desapercibida ni para todos los modelos, ni para aquellos que operan en niveles de dificultad elevados.

¿Qué hay de nuevo en la versión 3.6?

CrucibleForge 3.6.0 (18 de octubre de 2026) modifica la forma en que el proyecto se instala y ejecuta, pero no lo que mide. No ha habido cambios en los casos de prueba, en los correctores ni en las métricas; además, los resultados marcados como 3.5.1 siguen considerándose parte del mismo conjunto de casos. Por lo tanto, nada en los tableros existentes quedará obsoleto.

  • Docker. Se trata de una imagen de solo lectura y sin privilegios de root, de unos 190 MB, que incluye la interfaz gráfica en 127.0.0.1:8777. Sus archivos models.yaml y los resultados se almacenan en un volumen que persiste tras las actualizaciones. Dentro del contenedor, los casos de programación se ejecutan sin bwrap, ya que el propio contenedor actúa como entorno aislado; no obstante, puede acceder a la red, así que considere este entorno como un lugar donde se ejecuta código no confiable.
  • Windows. El conjunto de pruebas se ejecuta correctamente en Windows, y el sistema de integración continua cuenta con una etapa específica para esta plataforma. Una limitación: en Windows no se aplica el mecanismo que impide ejecutar dos pruebas simultáneamente; por eso, debe iniciarlas una por una.
  • Prueba automática de entorno aislado. Si se detecta que bwrap está instalado pero no puede realmente aislar el entorno (por ejemplo, dentro de un contenedor o cuando los espacios de nombres de usuario están bloqueados), la ejecución se cancela antes de comenzar. En ese caso, se rechaza la ejecución; sin embargo, con --allow-unsandboxed se permite la ejecución sin aislamiento, informándolo claramente desde el inicio, en lugar de hacer fallar todos los casos de prueba.
  • Claves API y mensajes de error más claros. status indica cuándo un servidor responde con códigos 401 o 403, además de nombrar la variable que debe configurarse; esto es precisamente lo que necesita una puerta de enlace StudioForge 2.0 para gestionar las claves API.
  • Corrección del 19-10-2026: Anteriormente, el botón “Judge pending rows” de la interfaz gráfica asignaba puntuaciones usando un corrector alternativo cuyos resultados no contaban para el tablero; ahora utiliza el corrector correspondiente al benchmark, tal como siempre ocurría desde la línea de comandos. Además, el panel de control ahora muestra el nombre de dicho corrector.

Actualización. De forma nativa, ejecute git pull && uv sync --python 3.13. Si su archivo models.yaml indica a StudioForge que use el puerto 8080, cámbielo a 1234: el puerto 8080 corresponde al panel de StudioForge, mientras que la API se encuentra en el puerto 1234. El archivo models.yaml existente nunca se sobrescribe automáticamente. En Docker, primero ejecute git pull y luego docker compose -f deploy/compose/compose.yml up -d --build; el volumen de datos se conserva, y down -v es el único comando que lo elimina.

Cómo se ve un informe

report genera un archivo Markdown y un archivo JSON. Cada modelo recibe una fila de resumen y una fila por categoría con los conteos brutos. Aquí está la fila por categoría del modelo 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 fallo se enumera junto con su razón. Los siete fallos de codificación que presentó parecen el primer renglón a continuación; el segundo renglón corresponde a uno de sus dos errores en el uso de herramientas:

- 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

Esa es la parte útil del informe. El modelo no escribió código deficiente; simplemente pensó hasta agotar el presupuesto de 32,768 tokens y nunca llegó a escribir nada. Un presupuesto mayor o un nivel de esfuerzo de razonamiento menor habrían cambiado esa puntuación. La tasa de aprobación por sí sola no permitiría saber eso.

Los modelos alojados también incluyen un Costo de ejecución en el informe, que corresponde al precio de una ejecución de las pruebas estándar (consulte la documentación de MakoBench).

Resultados del nivel difícil

Este es el tablero tal como quedó el 2026-11-09, reconstruido a partir de la ejecución del 2026-11-08 en la suite 4.1.0 y evaluado por gemma-4-31B. La puntuación sigue el sistema descrito anteriormente: cada categoría se puntúa sobre 10 en la prueba estándar; la puntuación general se calcula sobre 20 (sumando las puntuaciones de Codificación y Chat). Una categoría supera los 10 puntos únicamente al desbloquear un “paquete de escalada”, que consta de tres preguntas más difíciles, cada una valorada en 1 punto; este paquete se otorga solo si se alcanza el 90% en todas las demás tareas. La parte de Codificación es determinista (funciones, predicción y detección de errores, uso de herramientas); la parte de Chat es evaluada por el sistema (role-play profundo, conversación, creación de personajes y escritura creativa). El valor ± que acompaña a cada puntuación representa la mitad del intervalo del 90% obtenido mediante un método bootstrap sobre todos los casos; por lo tanto, dos modelos cuyos intervalos se solapan empatan, sin que haya un orden de clasificación.

Clase indica el rango general en el que se ubica una puntuación (S: a partir de 16, A: a partir de 13, B: a partir de 10). Filas completadas muestra el porcentaje de filas cuyos resultados se obtuvieron dentro del presupuesto de salida establecido; una fila que agotó su presupuesto se considera fallida. Algunas filas aún están pendientes de reintento, por lo que sus puntuaciones pueden variar. Costo de ejecución indica cuánto cuesta realizar una ejecución estándar según los precios del proveedor, considerando únicamente la generación de texto; el proceso de evaluación se realiza en nuestras propias tarjetas gráficas. El informe también muestra una velocidad media de generación, pero esta solo es comparable entre modelos ejecutados en el mismo host; como aquí utilizamos máquinas de distintos proveedores, omitimos este dato.

Nueva evaluación: hay un empate en todo el tablero

  • Una sola ejecución, un único juez, un solo día. Las 26 filas siguientes se ejecutaron y evaluaron el 2026-11-08, en la suite 4.1.0, utilizando gemma-4-31B como juez.
  • La prueba emparejada del propio tablero no logra diferenciar a ninguno de los modelos. El intervalo del 90% de cada par adyacente contiene el valor cero; estos empates se extienden hasta el final, por lo que el informe asigna la misma etiqueta de clasificación a las 26 filas. Los valores entre 19.3 y 11.3 deben interpretarse como estimaciones puntuales, no como un orden real.
  • MiniMax M3 por fin cuenta con una puntuación evaluada. En el tablero anterior solo tenía una puntuación en Codificación, sin valor general. Aquí alcanza 14.6 ± 1.7; además, la columna “Room” le asigna 15.5 tras volver a ejecutar dos filas que agotaron su presupuesto con un presupuesto mayor; aún queda pendiente un reintento. A unos $0.57 por ejecución, su costo es una séptima parte del modelo mejor clasificado.

Nivel difícil: tablero completo de 26 modelos

ModeloGeneralCodificaciónChatClaseFilas completadasCosto de ejecución
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 agotaron presupuesto)$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 agotaron presupuesto)$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 agotó presupuesto)$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 agotaron presupuesto)~$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 agotaron presupuesto)~$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*

Resumen de costos: una ejecución estándar de las 26 filas costó $68.21 en tokens del proveedor, considerando únicamente la generación de texto; el proceso de evaluación se realizó en nuestras propias tarjetas gráficas. La categoría de contenido para adultos, no cubierta en esta página, tiene un precio aparte. Doce de las 26 filas tuvieron un costo inferior a un dólar, sumando $4.87 en total; las otras 14 representan $63.34 del gasto total. Los dos modelos más caros, Claude Fable 5.1 y Claude Fable 5, aportan $19.93 de ese monto. Seis de los valores son estimaciones basadas en el conteo de tokens, no en facturaciones reales; tres incluyen un asterisco porque algunas solicitudes no devolvieron datos de uso, por lo que el total real es ligeramente superior.

Lo que no aparece en el tablero. Hay treinta y dos filas correspondientes a modelos fine-tuneados que ejecutamos en nuestras propias tarjetas; el informe marca a todas como incompletas, ya que sus ejecuciones no cubrieron todo el conjunto estándar de casos; por eso ninguna tiene puntuación general ni clasificación. Cuatro de ellas fallaron por completo: tres no obtuvieron permiso para usar la GPU y una se interrumpió a mitad de ejecución. Ocho modelos alojados también están pendientes: en tres casos el juez no ha evaluado veinte filas; cinco fueron rechazados por sus proveedores antes de poder ejecutarse. Todas las filas anteriores aún conservan algunas valoraciones asignadas bajo el sistema de puntuación anterior, a la espera de una nueva evaluación; por eso los números pueden variar ligeramente.

Las filas alojadas muestran los nombres de sus productos. Veinticuatro filas combinan resultados de la suite 4.0.1 con esta ejecución en la suite 4.1.0; DeepSeek V4 Flash y DeepSeek V4 Pro también incluyen datos de la versión 3.9.0. El símbolo “~” junto a un costo indica que el valor se estimó a partir del conteo de tokens según el precio listado; el asterisco señala que ciertas solicitudes no devolvieron datos de uso, por lo que el costo podría ser mayor. Cuatro filas pendientes muestran etiquetas de registro con nombres de modelos retirados que este sitio no publica.

Conclusiones extraídas:

  • Ningún modelo lidera realmente. Cada par adyacente en el tablero tiene un intervalo del 90% que contiene el valor cero; estos empates se extienden desde la primera hasta la última fila, por lo que el informe asigna la misma etiqueta de clasificación a los 26 modelos. La diferencia de ocho puntos entre el 19.3 de Kimi K3.1 Pro y el 11.3 de Claude Haiku 4.5 es meramente teórica; en esta ejecución todos son indistinguibles. Considere el orden como una estimación puntual.
  • El costo es el factor que realmente los diferencia. Una ejecución estándar de las 26 filas costó $68.21. DeepSeek V4 Flash obtiene 18.8 puntos por $0.14; Claude Fable 5.1 consigue 16.1 puntos por $10.23, lo que equivale a un costo casi 85 veces mayor por punto obtenido. Doce filas tuvieron un costo inferior al dólar, y cuatro de ellas lograron una puntuación igual o superior a 16.
  • La parte de Codificación marca la diferencia; Chat no. Solo DeepSeek V4 Flash (11.2) y DeepSeek V4 Pro (10.1) superan los 10 puntos en Codificación, y ambos desbloquearon el paquete de escalada; ningún modelo alcanza los 10 puntos en Chat, donde el mejor resultado es el 9.3 de Kimi K3.1 Pro. Si va a integrar un modelo en un agente, la columna de Codificación es la que debe priorizar.
  • El presupuesto de salida actúa como un filtro silencioso. Cinco filas agotaron su presupuesto: DeepSeek V4 Pro (5 filas), DeepSeek V4 Flash (4), MiniMax M3 y MiniMax M3.1 Flash (2 cada uno) y Claude Sonnet 4.6 (1). En el tablero, una fila que agota su presupuesto se considera fallida. Cuando existe una reejecución, la columna “Room” muestra la puntuación ajustada: MiniMax M3 alcanza 15.5 y MiniMax M3.1 Flash 14.5, valores que superan en 0.9 sus puntuaciones originales; para DeepSeek V4 Flash y Claude Sonnet 4.6, esos ajustes aún están pendientes.
  • Los filtros de contenido del proveedor restan puntos de forma real. Cuatro filas recibieron respuestas bloqueadas por el filtro de contenido del proveedor: Claude Fable 5 (6), Claude Opus 5 (2), Claude Fable 5.1 (2) y Claude Opus 5.5 (1); una respuesta bloqueada se puntúa como cero. Además, cinco filas presentan al menos un resultado que el juez no pudo interpretar.

Descarga

El archivo descargable es bench-llm, la versión original ahora obsoleta; no se trata de CrucibleForge (que se encuentra en GitHub). El archivo ZIP contiene dos ficheros: bench-llm, el script de 1.660 líneas, y README.md, que incluye instrucciones resumidas para la configuración. No es necesario compilar ni instalar nada más; basta con descomprimir y ejecutar. El agente generó ambos archivos, los cuales están bajo licencia MIT. Las dependencias son openai y requests. Lea las advertencias antes de ejecutarlo en una máquina que sirva otros servicios.

Relacionado: StudioForge (el servidor con GPU del cual estos modelos alquilan tarjetas gráficas), Cuánto cuestan realmente mis agentes de IA (por qué la velocidad local es importante), DeepSeek Harness (un agente de programación respaldado por estos modelos) y la pila de agentes de IA local en la que operan.

Descargas

Gratis para uso personal. Si te ahorra una tarde, el botón del café está aquí cerca.


← Más de IA y LLM Local More MakoBench articles →