Local Model Benchmarks

Workflow para descubrir modelos locales, compararlos con benchmarks ya corridos, ejecutar nuevos benchmarks con whatcanirun, y opcionalmente submitear resultados.

Regla principal: NO descargar modelos. Solo trabajar con lo que ya está descargado localmente.

Fase 1 — Discovery de modelos locales

Escanear las dos ubicaciones de modelos locales y presentar una tabla consolidada.

Modelos MLX (HuggingFace cache)

ls -d ~/.cache/huggingface/hub/models--* 2>/dev/null | while read dir; do
  basename "$dir" | sed 's/^models--//' | tr '--' '/'
done

El nombre de carpeta sigue el patrón models--{org}--{model}. Extraer org, modelo, y quantización del nombre.

Modelos GGUF (LM Studio)

find ~/.lmstudio/models -name "*.gguf" -not -name "mmproj-*" 2>/dev/null

Importante: Filtrar archivos mmproj-*.gguf — son proyectores multimodales, no modelos benchmarkeables.

Verificar metadata de un modelo

npx whatcanirun show model <path-o-hf-repo>

Retorna: display_name, format, quant, architecture, parameters, file_size_bytes, artifact_sha256.

Tabla de resultados

Presentar los modelos encontrados en formato:

#	Modelo	Formato	Quant	Tamaño	Runtime
1	Qwen3.5-27B	MLX	4bit	~15 GB	mlx_lm
2	Qwen3.5-27B	GGUF	q6_k	~22 GB	llama.cpp

La asignación de runtime es automática: MLX → mlx_lm, GGUF → llama.cpp.

Fase 2 — Comparar con benchmarks existentes

Leer los bundles existentes y cruzar con los modelos descubiertos.

Listar benchmarks corridos

for zip in ~/.whatcanirun/bundles/*.zip; do
  unzip -p "$zip" manifest.json 2>/dev/null | python3 -c "
import sys, json
m = json.load(sys.stdin)
model = m['model']
rt = m['runtime']
print(f\"{model['display_name']} | {model['format']} | {model['quant']} | {rt['name']} | {model.get('artifact_sha256','')[:12]}\")" 2>/dev/null
done

Cruzar modelos vs benchmarks

Comparar por SHA256 del artifact (más confiable) o por nombre + quant si no hay SHA disponible. Marcar cada modelo local con su estado:

#	Modelo	Quant	Estado
1	Qwen3.5-27B-4bit	4bit	✗ nuevo
2	Qwen3.5-27B-Q6_K	q6_k	✓ corrido (9.2 tok/s decode)

Ver resultados de un benchmark existente

unzip -p ~/.whatcanirun/bundles/<bundle>.zip results.json | python3 -c "
import sys, json
r = json.load(sys.stdin)['aggregate']
print(f\"Decode: {r['decode_tps_mean']} tok/s | Prefill: {r['prefill_tps_mean']} tok/s | TTFT p50: {r['ttft_p50_ms']:.0f}ms | Mem: {r['peak_rss_mb']:.0f} MB\")"

Fase 3 — Selección y ejecución

Preguntar al usuario cuáles modelos correr. Ofrecer correr todos los nuevos (estado ✗) como opción por defecto.

Configuración

Preguntar si usar defaults o customizar:

Parámetro	Default	Descripción
--trials	10	Cantidad de repeticiones
--prompt-tokens	4096	Tokens de prompt
--gen-tokens	1024	Tokens a generar

Ejecutar benchmark

npx whatcanirun run \
  --model <hf-repo-id-o-path-local> \
  --runtime <mlx_lm|llama.cpp> \
  --trials 10

Para modelos MLX, usar el HuggingFace repo ID (e.g., mlx-community/Qwen3.5-27B-Claude-4.6-Opus-Distilled-MLX-4bit).

Para modelos GGUF, usar el path absoluto al archivo .gguf.

Interpretar resultados

Métricas clave del benchmark:

• decode_tps: Tokens/segundo de generación — velocidad percibida por el usuario
• prefill_tps: Tokens/segundo de procesamiento del prompt — afecta TTFT
• ttft_p50_ms: Time To First Token mediana — latencia inicial
• peak_rss_mb: Memoria pico — verificar que no se acerque a 64 GB (riesgo OOM)

Si peak_rss_mb supera 55,000 MB, advertir riesgo de OOM para otros usos simultáneos.

Fase 4 — Submit (opcional)

Preguntar al usuario si quiere subir los resultados a whatcani.run.

Verificar autenticación

npx whatcanirun auth status

Si no está logueado, ejecutar npx whatcanirun auth login primero.

Submitear resultados

Opción A — submit automático al correr:

npx whatcanirun run --model <model> --runtime <runtime> --submit

Opción B — submit de bundle existente:

npx whatcanirun submit <bundle-id-o-path>

Validar bundle antes de submit

npx whatcanirun validate <bundle-id-o-path>

Gotchas

• No descargar modelos — este skill solo trabaja con modelos ya presentes localmente
• mmproj-*.gguf son proyectores multimodales de visión, no modelos de texto — siempre filtrarlos
• Benchmarks largos: con 10 trials y 4096+1024 tokens, cada benchmark toma varios minutos. Reducir trials a 3 para pruebas rápidas
• Un modelo a la vez: no correr benchmarks en paralelo — compiten por memoria y GPU, invalida resultados
• Memoria: M4 Max tiene 64 GB compartidos CPU/GPU. Modelos >50 GB van a tener degradación por swap
• whatcanirun show model puede fallar con paths de LM Studio que tienen espacios — usar comillas

Additional Resources

Reference Files

Para detalle completo del CLI, estructura de bundles y schemas:

• references/whatcanirun-cli.md — Referencia completa de whatcanirun: comandos, flags, formato de bundles, schema de resultados