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