# Cuantización GGUF: elige el archivo correcto para tu máquina

> Las familias de cuantización GGUF explicadas, cómo leer el nombre de un archivo, calcular si cabe con contexto y ranuras, y cuantizar tú mismo con llama.cpp.

- Publicado: 2026-09-09
- Revisado: 2026-11-15
- Autor: Jacobo González Jaspe
- Idioma: es
- Etiquetas: Cuantización, GGUF, Ollama, IA Local, Hardware
- URL canónica: https://vorluxai.com/blog/gguf-quantization-pick-the-right-file-for-your-hardware-es/
- Fuente: VORLUX AI (J4SGON S.L.), https://vorluxai.com/

---

Al terminar esta guía sabrás abrir la página de descarga de un modelo, elegir el archivo que cabe en tu máquina y comprobar la elección. Basta un portátil con 8 GB de memoria. Herramientas y opciones están contrastadas con el código de llama.cpp y Ollama a 15 de noviembre de 2026.

> **TL;DR**
> - Qué te llevas: las cuatro familias de cuantización, una regla de tamaño con nuestras mediciones y los comandos para cuantizar tú mismo.
> - Qué cuesta: elegir archivo, nada. Cuantizar un modelo de 7B nos llevó 46,5 segundos en CPU.
> - Veredicto: empieza con Q4_K_M. Usa Q8_0 si archivo más contexto siguen cabiendo. Baja de 4 bits solo para meter un modelo mucho mayor.

## Qué necesitas

- Un ordenador con 8 GB de memoria y [Ollama](https://vorluxai.com/blog/instalar-ollama-primer-llm-local-es/). Los nuestros son 0.30.10 y 0.34.0.
- Solo para el paso 6: [llama.cpp](https://github.com/ggml-org/llama.cpp) compilado (la [1.0.0](https://github.com/ggml-org/llama.cpp/releases/tag/v1.0.0) salió el 13-11-2026).

## Paso 1: lee el nombre del archivo

GGUF es el formato que cargan llama.cpp, Ollama y LM Studio. Su [especificación](https://github.com/ggml-org/ggml/blob/master/docs/gguf.md) fija los nombres, con las partes unidas por guiones:

```
[<Sidecar>]<BaseName><SizeLabel><FineTune><Version><Encoding><Type><Shard>.gguf
Grok-100B-v1.0-Q4_0-00003-of-00009.gguf
mmproj-Qwen2-VL-7B-v1.0-F16.gguf
```

- **SizeLabel** (`100B`): cuántos pesos tiene. Es lo que más mueve memoria y velocidad.
- **Encoding** (`Q4_0`, `F16`): cómo se guarda cada peso (paso 2).
- **Shard** (`00003-of-00009`): modelo partido: necesitas todos los archivos.
- **Sidecar** (`mmproj-`): un archivo adicional para imágenes o audio, no el modelo.

Algunos autores añaden etiquetas propias. En la [página de Llama 3.3 70B de bartowski](https://huggingface.co/bartowski/Llama-3.3-70B-Instruct-GGUF), `Q4_K_L` es un Q4_K_M con los pesos de entrada y salida en Q8_0; llama.cpp no tiene ese tipo.

## Paso 2: conoce las cuatro familias

| Familia | Nombres | Cómo guarda los pesos |
|---|---|---|
| Sin cuantizar | `F32`, `F16`, `BF16` | Coma flotante original. El origen para cuantizar |
| Clásica (legacy) | `Q4_0`, `Q5_0`, `Q8_0` | Bloques de 32 pesos, con redondeo simple |
| K-quants | `Q2_K` a `Q6_K`, con `_S` `_M` `_L` | Bloques dentro de superbloques, con escalas compactadas |
| I-quants | `IQ1_S` a `IQ4_XS` | Superbloques de 256 pesos, ajustados con una matriz de importancia |

La estructura sale de la [referencia GGUF de Hugging Face](https://huggingface.co/docs/hub/gguf), que da los tipos clásicos por poco usados hoy. Aun así, `ollama show llava:7b` responde `Q4_0` en nuestra máquina.

**`_S`, `_M`, `_L`.** Un K-quant es una mezcla: unos pocos tensores sensibles llevan más bits de los que dice el nombre. Nuestro Q4_K_M del paso 6 tiene 169 tensores en Q4_K y 29 en Q6_K. `_S` sube menos.

**Una matriz de importancia no es un I-quant.** Son datos de calibración: [`llama-imatrix`](https://github.com/ggml-org/llama.cpp/blob/master/tools/imatrix/README.md) pasa texto de muestra por el modelo y apunta qué pesos importan. Los K-quants también pueden usarla ([PR 4930](https://github.com/ggml-org/llama.cpp/pull/4930)), con `--imatrix` en `llama-quantize`; los archivos de bartowski la llevan todos. No generamos ninguna; los comandos están en el paso 6.

**Los I-quants no salen gratis fuera de la GPU.** La ficha de bartowski dice que funcionan en CPU y en Apple Metal, pero más despacio que el K-quant de tamaño parecido, y que no funcionan con Vulkan. El aviso está en la ficha de un modelo ya antiguo, así que compruébalo en tu entorno. La tabla de llama.cpp para Llama 3.1 8B da 70,15 tokens por segundo a IQ3_M y 71,68 a Q3_K_M, sin decir en qué equipo. No hemos cronometrado ningún I-quant.

**Tipos más recientes.** La [herramienta](https://github.com/ggml-org/llama.cpp/blob/master/tools/quantize/quantize.cpp) lista además `TQ1_0` y `TQ2_0`, para modelos entrenados con pesos de tres valores ([PR 8151](https://github.com/ggml-org/llama.cpp/pull/8151)), y `MXFP4_MOE`, `Q1_0` y `Q2_0`. No los hemos usado.

## Paso 3: conoce los tamaños

| Tipo | Qwen2.5 7B, nuestra simulación | Bits por peso, misma ejecución | Llama 3.1 8B, llama.cpp | Aumento de perplejidad (Llama 3 8B) |
|---|---|---|---|---|
| IQ2_XS | 2.348,96 MiB | 2,59 | 2,42 GiB | no figura |
| Q2_K | 2.870,55 MiB | 3,16 | 2,95 GiB | +3,5199 |
| IQ3_M | 3.402,77 MiB | 3,75 | 3,52 GiB | no figura |
| Q3_K_M | 3.626,29 MiB | 3,99 | 3,74 GiB | +0,6569 |
| IQ4_XS | 4.047,72 MiB | 4,46 | 4,17 GiB | no figura |
| Q4_0 | 4.220,43 MiB | 4,65 | no figura | +0,4685 |
| Q4_K_S | 4.245,58 MiB | 4,68 | 4,36 GiB | +0,2689 |
| Q4_K_M | 4.460,45 MiB | 4,91 | 4,58 GiB | +0,1754 |
| Q5_K_S | 5.063,27 MiB | 5,58 | 5,21 GiB | +0,1049 |
| Q5_K_M | 5.186,92 MiB | 5,71 | 5,33 GiB | +0,0569 |
| Q6_K | 5.958,79 MiB | 6,56 | 6,14 GiB | +0,0217 |
| Q8_0 | 7.717,68 MiB | 8,50 | 7,95 GiB | +0,0026 |

Fuentes: nuestra ejecución, [gguf-quantize-run-2026-11-15.json](https://vorluxai.com/data/measurements/gguf-quantize-run-2026-11-15.json), en la que `llama-quantize --dry-run` imprimió cada tamaño sin escribir ningún archivo; el [README de quantize](https://github.com/ggml-org/llama.cpp/blob/master/tools/quantize/README.md) de llama.cpp para los tamaños de Llama 3.1 8B; y la lista de tipos de la herramienta para la perplejidad (leídos el 15-11-2026). El archivo de origen ocupaba 14.526,27 MiB a 16 bits. Las filas de I-quants se calcularon sin matriz de importancia, e IQ2_XS no se puede generar sin ella.

Dos lecturas. El clásico `Q4_0` y `Q4_K_S` se llevan 25 MiB, y el K-quant pierde bastante menos. Por debajo de Q4 la pérdida sube deprisa.

llama.cpp imprime MiB y GiB; Ollama y Hugging Face muestran GB decimales. Para un modelo sin tabla: `tamaño ≈ parámetros × bits por peso ÷ 8`. Los bits por peso no son una constante, porque la mezcla de tensores cambia con el modelo: el README de llama.cpp da 4,8944 para Q4_K_M en Llama 3.1 8B, y nuestra ejecución imprimió 4,91 en Qwen2.5 7B. Con 4,89, un 14B ocupa unos 8,6 GB.

## Paso 4: calcula si cabe

Un modelo cargado reserva además una caché para la conversación, una por ranura en paralelo. La memoria es el archivo, más contexto por ranuras por un coste por token, más 1 o 2 GB de margen.

Medido el 2-11-2026 con un archivo de 4,9 GB, `llama3.1:8b` en Q4_K_M, en nuestras dos DGX Spark (GB10, 128 GB de memoria unificada, Ollama 0.30.10 y 0.34.0), según `ollama ps`. Datos: [ollama-num-ctx-2026-11-02.json](https://vorluxai.com/data/measurements/ollama-num-ctx-2026-11-02.json).

| Ranuras | `num_ctx` | Tamaño cargado |
|---|---|---|
| 1 | 4.096 | 5,27 GB |
| 1 | 32.768 | 9,21 GB |
| 8 | 4.096 | 9,15 GB |
| 4 | 32.768 | 22,38 GB |
| 8 | 32.768 | 39,27 GB |

El mismo archivo ocupó entre 5,27 y 39,27 GB: lo que cuenta es ranuras por contexto. No todos los modelos pagan igual: [cuánta memoria cuesta el contexto en Ollama](https://vorluxai.com/blog/ollama-longitud-contexto-memoria-medida-es/). La cuenta a mano: [¿cuánta VRAM necesito?](https://vorluxai.com/blog/cuanta-vram-necesito-llm-local-es/).

Fija tú el contexto. La [página de longitud de contexto](https://docs.ollama.com/context-length) de Ollama (leída el 15-11-2026) da 4k con menos de 24 GiB de VRAM, 32k hasta 48 GiB y 256k por encima, y su [FAQ](https://docs.ollama.com/faq) dice que las peticiones en paralelo lo multiplican. En nuestra segunda Spark ese valor, con ocho ranuras, tumbó las cargas hasta que cada modelo llevó su propio `num_ctx`.

**Encoger la caché en vez del modelo.** La FAQ de Ollama documenta `OLLAMA_KV_CACHE_TYPE`. Por defecto vale `f16`; `q8_0` ocupa más o menos la mitad de la memoria de caché y `q4_0` una cuarta parte. Requiere Flash Attention, se aplica a todos los modelos del servidor, y la FAQ avisa de que algunos modelos, Qwen2 entre ellos, pueden perder más precisión. En llama.cpp las opciones son `-ctk` y `-ctv`. Reduce solo la parte del contexto, nunca el archivo. No lo hemos probado.

Después ejecuta `ollama ps`: `PROCESSOR` debe decir `100% GPU`. Si muestra un reparto como el `48%/52% CPU/GPU` de la FAQ, baja `num_ctx` y después la cuantización.

## Paso 5: comprueba qué cuantización sirve Ollama

Una etiqueta sin más esconde el archivo. En nuestra máquina (Ollama 0.30.10, 15-11-2026), primer bloque de la salida:

```bash
ollama show llama3.1:8b
#   Model
#     architecture        llama
#     parameters          8.0B
#     context length      131072
#     embedding length    4096
#     quantization        Q4_K_M
```

En un script, lee `details.quantization_level` de `/api/show`. Los demás archivos están en la [página de etiquetas](https://ollama.com/library/llama3.1/tags), de `8b-instruct-q2_K` a `8b-instruct-fp16`. Ollama también descarga archivos GGUF directamente de Hugging Face. Según la [guía del Hub](https://huggingface.co/docs/hub/ollama) (leída el 15-11-2026):

```bash
ollama run hf.co/<usuario>/<repo>          # Q4_K_M si el repositorio lo tiene
ollama run hf.co/<usuario>/<repo>:Q8_0     # una cuantización concreta, en mayúsculas o minúsculas
```

Si el repositorio no tiene Q4_K_M, el Hub elige otro archivo por ti, así que pide el que quieres; el nombre completo del archivo también vale como etiqueta. No ejecutamos estos comandos.

## Paso 6: cuantiza un modelo tú mismo

Solo si nadie publica el archivo que quieres.

```bash
git clone https://github.com/ggml-org/llama.cpp && cd llama.cpp
cmake -B build && cmake --build build --config Release -j 8
python3 -m pip install -r requirements.txt

# fase 1: pesos de Hugging Face -> GGUF de 16 bits
python3 convert_hf_to_gguf.py /ruta/al/modelo --outfile modelo-f16.gguf --outtype f16
# fase 2: primero el tamaño, después cuantizar con 8 hilos
./build/bin/llama-quantize --dry-run modelo-f16.gguf Q4_K_M
./build/bin/llama-quantize modelo-f16.gguf modelo-Q4_K_M.gguf Q4_K_M 8
```

Ejecutamos solo la fase 2, con una compilación de julio de 2026. El origen fue el archivo FP16 de Qwen2.5 7B que Ollama guarda en disco; `ollama show qwen2.5:7b-instruct-fp16 --modelfile` da su ruta en la línea `FROM`. En nuestra primera DGX Spark, solo con CPU:

```
llama_model_quantize_impl: model size  = 14526.27 MiB (16.00 BPW)
llama_model_quantize_impl: quant size  =  4460.45 MiB (4.91 BPW)
llama_quantize: quantize time = 46515.99 ms
```

Un archivo de 15,24 GB pasó a 4,68 GB, el tamaño que Ollama da a su propia etiqueta Q4_K_M. Leído de vuelta, su tipo es 15, `MOSTLY_Q4_K_M` en la especificación. No lo cargamos. El proceso llegó a 14.885.452 kB de memoria residente, más o menos el tamaño del archivo de origen: el README dice que el modelo se lee entero en memoria, así que cuenta con RAM para el archivo de 16 bits.

**Con matriz de importancia.** Hace falta para los tipos más pequeños (están con los errores, más abajo) y es opcional para el resto. Del [README de imatrix](https://github.com/ggml-org/llama.cpp/blob/master/tools/imatrix/README.md), a 15-11-2026:

```bash
# 1. pasa texto de calibración por el modelo de 16 bits; escribe imatrix.gguf
./build/bin/llama-imatrix -m modelo-f16.gguf -f calibracion.txt -o imatrix.gguf -ngl 99
# 2. cuantiza con ella
./build/bin/llama-quantize --imatrix imatrix.gguf modelo-f16.gguf modelo-IQ3_M.gguf IQ3_M 8
```

`-m` y `-f` son obligatorios. `-ngl 99` lleva el cálculo a la GPU, que es lo que el README recomienda por velocidad; quítalo si trabajas con CPU. `--chunks` limita cuánto texto se procesa. bartowski enlaza en su ficha el texto de calibración que usa. No ejecutamos ninguno de los dos comandos: nuestra compilación no trae `llama-imatrix` y en esta guía solo usamos la CPU.

**Sin compilar nada.** El README de quantize remite al Space [GGUF-my-repo](https://huggingface.co/spaces/ggml-org/gguf-my-repo) de Hugging Face. Se ejecuta en sus servidores, así que no sirve para pesos que no pueden salir de casa. No lo hemos usado.

Para cargarlo en Ollama: un Modelfile con `FROM ./modelo-Q4_K_M.gguf` y `ollama create mi-modelo`. No lo ejecutamos. Cuantiza antes: la [página de importación](https://docs.ollama.com/import) (leída el 15-11-2026) dice que Ollama no cuantiza archivos GGUF, y `-q` es solo para safetensors en el [código actual](https://github.com/ollama/ollama/blob/main/cmd/cmd.go). Para comparar la calidad, mira [llama-perplexity](https://github.com/ggml-org/llama.cpp/blob/master/tools/perplexity/README.md).

## Qué medimos

Qwen2.5 7B Instruct en tres archivos, 5-11-2026, primera DGX Spark, Ollama 0.30.10. Velocidad con un prompt de 278 palabras; precisión con 40 facturas sintéticas. Datos: [quantization-speed-2026-11-05.json](https://vorluxai.com/data/measurements/quantization-speed-2026-11-05.json) y [structured-extraction-2026-11-05.json](https://vorluxai.com/data/measurements/structured-extraction-2026-11-05.json).

| Codificación | Archivo | Generación | Facturas sin ningún error |
|---|---|---|---|
| Q4_K_M | 4,68 GB | 42,7 tok/s | 26 de 40 |
| Q8_0 | 8,10 GB | 28,2 tok/s | 34 de 40 |
| FP16 | 15,24 GB | 16,5 tok/s | 34 de 40 |

Q8_0 acertó ocho facturas más al 66 % de la velocidad de Q4_K_M. FP16 no añadió nada. Es un modelo y una tarea; el análisis está en [Q4, Q8 o FP16, medido](https://vorluxai.com/blog/q4-q8-fp16-cuantizacion-medido-es/).

## Lo que no te dicen

- **«requantizing from type q4_K is disabled».** Nos salió al pedir Q3_K_M a partir de un Q4_K_M. Parte del archivo de 16 bits: la precisión no se recupera. `--allow-requantize` lo fuerza. La simulación no lo detectó.
- **«this quantization requires an importance matrix!».** Nos salió al pedir `IQ2_XS` sin matriz. El [código](https://github.com/ggml-org/llama.cpp/blob/master/src/llama-quant.cpp) la exige para los I-quants de 1 y 2 bits, `IQ3_XXS` y `Q2_K_S`.
- **La simulación solo avisa.** Con la misma petición de IQ2_XS, `--dry-run` imprimió un tamaño, salió con 0 y avisó de que completarla «will require an imatrix».
- **Un modelo partido abierto por el archivo equivocado.** bartowski parte todo lo que pasa de 50 GB, y su tabla marca también como partido el Q5_K_M de 49,95 GB. El [cargador](https://github.com/ggml-org/llama.cpp/blob/master/src/llama-model-loader.cpp) de llama.cpp lanza `illegal split file idx` con la indicación «model must be loaded with the first split». Deja todos los trozos en la misma carpeta, con su nombre original, y apunta al `-00001-of-`. Para tener un solo archivo: `llama-gguf-split --merge primer-trozo.gguf unido.gguf` ([README](https://github.com/ggml-org/llama.cpp/blob/master/tools/gguf-split/README.md)). La página de importación de Ollama admite un comodín, `FROM /ruta/al/modelo-*.gguf`. El texto del error sale del código; no lo reprodujimos.
- **El servidor de llama.cpp cuenta distinto.** Ahí `-c` es un total que las ranuras comparten o dividen ([código](https://github.com/ggml-org/llama.cpp/blob/master/src/llama-context.cpp)). Además, `--fit` viene activado: según el [README del servidor](https://github.com/ggml-org/llama.cpp/blob/master/tools/server/README.md), ajusta los argumentos que no hayas fijado para que quepan en la memoria del dispositivo, deja 1.024 MiB libres por dispositivo y no baja de 4.096 tokens. Allí un contexto sin fijar significa «todo lo que quepa», mientras que Ollama va por tramos. Fíjalo con `-c`. No lo ejecutamos.

## Tabla de decisión por memoria

«Memoria» es la que el modelo puede usar: la VRAM, o la memoria unificada menos el sistema. Los tamaños «cargado» son nuestros, con una ranura salvo indicación; el resto son de archivo.

| Memoria | Cómodo | Justo: contexto corto, una ranura | Descarta, y por qué |
|---|---|---|---|
| 8 GB | 8B Q4_K_M (5,27 GB cargado, 4k) | 8B Q5_K_M (5,33 GiB) | 8B Q8_0 (7,95 GiB): no deja sitio al contexto |
| 12 GB | 7B Q8_0, 4k (7,89 GB cargado) | 7B Q8_0, 32k (9,74 GB cargado) | 14B a 32k: el nuestro cargó 15,29 GB |
| 16 GB | 14B Q4_K_M (8,99 GB) | 24B Q4_K_M (14,33 GB) | 7B FP16 (15,24 GB): misma nota que Q8_0 en nuestra prueba |
| 24 GB | 26B Q4_K_M (17,47 GB cargado, 32k) | 32B Q4_K_M (unos 19,6 GB por fórmula) | 70B IQ2_XXS (19,10 GB): bartowski lo califica de calidad muy baja |
| 32 GB | 35B Q4_K_M (23,47 GB cargado, ocho ranuras de 32k) | 70B Q2_K (26,38 GB) | 70B Q3_K_S (30,91 GB): la ficha lo desaconseja, y no queda margen |
| 48 GB | 70B IQ4_XS (37,90 GB) | 70B Q4_K_M (42,52 GB) | 70B Q5_K_S (48,66 GB): el archivo solo ya la llena |
| 64 GB | 70B Q5_K_M (49,95 GB) | 70B Q6_K (57,89 GB) | 70B Q8_0 (74,98 GB): no cabe, y la ficha dice que rara vez hace falta |

El contexto decide: nuestro 14B cargó 15,29 GB a 32k. Nuestras cifras: [dgx-spark-review-prime-2026-11-02.json](https://vorluxai.com/data/measurements/dgx-spark-review-prime-2026-11-02.json), [mistral-small-24b-speed-ctx4k-2026-11-15.json](https://vorluxai.com/data/measurements/mistral-small-24b-speed-ctx4k-2026-11-15.json), [structured-extraction-2026-11-05.json](https://vorluxai.com/data/measurements/structured-extraction-2026-11-05.json) y el archivo de num_ctx. Los tamaños de 8B y 70B son de llama.cpp y de bartowski. No hemos ejecutado un 70B: esas filas dejan uno o dos gigas libres, como aconseja bartowski.

## Cuándo no hacerlo

- **No cuantices tú** si un repositorio mantenido ya publica el archivo. Te ahorras compilar, descargar los 16 bits y calibrar.
- **No bajes de 4 bits para arañar un poco.** Sirve para meter una clase de modelo que de otro modo no podrías ejecutar, y entonces lo pruebas.
- **No bajes a Q4 sin medir en trabajos donde un dígito mal es una respuesta mal:** en nuestra prueba de facturas costó ocho documentos de 40.
- **No recuantices un archivo ya cuantizado.** Vuelve al origen de 16 bits.
- **No cambies de cuantización para arreglar un problema de memoria sin haber fijado antes `num_ctx` y las ranuras.** En el paso 4 movieron el mismo archivo de 5,27 a 39,27 GB.
- **No sirvas en FP16.** Guárdalo como origen para nuevas cuantizaciones.

## Veredicto

- **Compra: Q4_K_M** por defecto. La etiqueta `llama3.1:8b` es ese archivo.
- **Compra: Q8_0** para extraer datos donde un carácter importa, si cabe con margen.
- **Espera: I-quants** hasta que un modelo mayor no quepa de otro modo. Entonces compáralo con el pequeño en Q4_K_M.
- **Sáltatelo: FP16** para ejecutar, y no cuantices tú cuando un repositorio mantenido ya tenga el archivo.

## Preguntas frecuentes

**¿Basta con Q4_K_M?** Es el punto de partida habitual: llama.cpp le apunta +0,1754 de perplejidad en Llama 3 8B. En nuestra tarea de extracción acertó 26 facturas frente a las 34 de Q8_0. Depende de la tarea, así que prueba la tuya.

**¿Un archivo más pequeño va más rápido?** En nuestra prueba, sí: 42,7 tokens por segundo en Q4_K_M, 28,2 en Q8_0 y 16,5 en FP16. La tabla de llama.cpp para Llama 3.1 8B va en el mismo sentido (71,93, 50,93 y 29,17).

**¿Un modelo mayor con menos bits o uno menor con más?** No lo hemos medido. La perplejidad de dos modelos distintos no se puede comparar, así que la respuesta honrada es ejecutar tu propia tarea con los dos.

**¿Puedo convertir un Q4 de vuelta en Q8?** No. `llama-quantize` se niega, y si lo fuerzas obtienes un archivo mayor con los errores del Q4 dentro. Descarga el archivo grande.

**¿Necesito una matriz de importancia?** Solo para los tipos que se niegan a generarse sin ella. En los K-quants es opcional, y los archivos de bartowski ya la llevan.

**¿Q4_K_M, Q4_K_S o Q4_0?** En nuestro 7B, Q4_K_S ahorra 215 MiB frente a Q4_K_M y Q4_0 ahorra 240, con un aumento de perplejidad de +0,2689 y +0,4685 en lugar de +0,1754 en la lista de llama.cpp. Quédate con Q4_K_M salvo que esos megas decidan si cabe.

**¿Por qué el tamaño cargado es mayor que el archivo?** Por la caché de contexto, una por ranura. Está en el paso 4.

## Siguientes pasos

- Elige el modelo antes que el archivo: [mejores LLM locales según hardware y tarea](https://vorluxai.com/blog/mejores-llm-locales-segun-hardware-tarea-es/), o el [explorador de VRAM](https://vorluxai.com/tools/vram-explorer/).
- ¿No te cabe nada? El [catálogo de hardware para IA local](https://vorluxai.com/blog/local-ai-hardware-catalog-2026-what-to-buy-at-each-budget-es/) va por presupuesto.
- ¿Dudas de si lo local compensa? [Calcula tu punto de equilibrio frente a la nube](https://vorluxai.com/blog/cloud-vs-local-ai-cost-benchmarks-es/).
- Cronometra dos archivos en tu máquina: [mide un modelo local en 30 minutos](https://vorluxai.com/blog/benchmark-modelo-local-tu-ordenador-30-minutos-es/).

## Trabaja con nosotros

Hacemos esta medición en el hardware de cada cliente antes de recomendar un modelo. Para una segunda opinión sobre un archivo o una máquina, [escríbenos](https://vorluxai.com/contact/) o mira [cómo trabajamos en consultoría](https://vorluxai.com/consulting/).
