Artículo · · 17 min de lectura
Un modelo de 125B en un ordenador de 1400 euros. Pongo a prueba Strata con mi propio benchmark
Me interesó la posibilidad de ejecutar grandes modelos de lenguaje en local sin gastar una fortuna en una tarjeta gráfica y un ordenador. Mi máquina completa costó unos 6000 eslotis polacos (más o menos 1400 euros): un procesador de servidor Intel Xeon E5-2699 v4 de 2016, 121 GB de RAM DDR4 (eso es lo que ve el sistema), un disco NVMe y una GeForce RTX 3060 con 12 GB de memoria.
Durante varias semanas Strata apareció en mi feed desde distintas fuentes: GitHub, Reddit, boletines sobre modelos locales. La promesa era siempre la misma: Qwen3.8-Flash-Next, el modelo abierto de Alibaba con 125 000 millones de parámetros, en una sola tarjeta de 12 GB, a más de 50 tokens por segundo. Decidí medirlo y comprobar después, con un benchmark propio, si un modelo así vale más que los cuatro modelos más pequeños que son la elección natural en un ordenador como este.
Qué es Strata
Strata es un motor de código abierto (licencia MIT) de un solo autor con el seudónimo Niko1221, sin relación con el equipo de Qwen, construido en torno a Qwen3.8-Flash-Next: un modelo de tipo mixture of experts en el que, de los 125 000 millones de parámetros, en cada token trabajan unos 6000 millones. Strata mantiene todos los «expertos» en la RAM, deja en la tarjeta las capas de atención y una reserva de los expertos más usados, calcula el resto en el procesador, y una pequeña capa adicional (MTP, multi-token prediction) propone varios tokens por adelantado que el modelo completo verifica en una sola pasada; según la documentación la respuesta es la misma, solo que más rápida (detalles de los mecanismos).
Instalación y requisitos
La instalación mediante el comando strata en el terminal no requiere permisos de administrador y lo guarda todo en el directorio del usuario:
curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh | sh
strata launch --plan --model iq3_s # muestra el plan, no cambia nada
strata launch --model iq3_s --context 128k --yes --no-tui
El script comprueba la suma SHA-256 y la firma de la versión del archivo del motor que descarga; el propio script, como siempre con curl | sh, llega sin verificar, así que lo guardé en un fichero y lo leí antes de ejecutarlo. El motor y el modelo con sus complementos suman 90 GB de descarga; la carga del modelo tarda alrededor de un minuto. El servidor expone una API compatible con OpenAI (http://127.0.0.1:8080/v1), otra compatible con Anthropic y un chat en el navegador.
El modelo está disponible en varios niveles de cuantización, es decir, de almacenamiento de los pesos con menos bits en lugar de 16: ficheros más pequeños, menos RAM, respuestas algo peores. El instalador suma la RAM a la memoria de la tarjeta, resta 5 GB para el sistema y a partir de cada umbral propone la siguiente variante:
| Umbral del instalador (RAM + VRAM − 5 GB) | Variante | Expertos en RAM |
|---|---|---|
| 32 GB | Coder IQ1_M, la mitad de los expertos, elegidos para programar | 23 GB |
| 40 GB | IQ2_XS | 35,5 GB |
| 48 GB | IQ3_XXS | 43 GB |
| 64 GB | IQ3_S, la probada aquí | 50 GB |
Lo que más cuenta es la RAM, porque los expertos tienen que caber en ella por completo: 50 GB para IQ3_S, y la documentación recomienda 60 GB y dice que con 64 GB la variante funciona cuando hay pocos programas más abiertos. En mi máquina el proceso del motor ocupaba 83 GB, porque con más de 107 GB de RAM Strata carga también en memoria una tabla de embeddings de n-gramas de 29 GB que normalmente se queda en el disco. La tarjeta necesita al menos 12 GB y el procesador debe soportar AVX2; una tarjeta mayor acelera el modelo, porque aloja más expertos, pero no reduce la RAM necesaria.
IQ3_S guarda los pesos con unos 3,3 bits. Los autores miden la calidad de la compresión sobre 5000 tokens de texto, comprobando con qué frecuencia la variante elige el mismo token más probable que la versión de 8 bits: IQ3_S en el 87,7 % de las posiciones, la UD-Q4_K_XL de 4 bits en el 93,1 %, IQ3_XXS en el 84,5 % y la más pequeña, Q2_0, en el 80,6 %. Es una medida distinta de un benchmark: un token diferente no tiene por qué cambiar el sentido de la respuesta, y con qué frecuencia lo cambia es algo que la documentación no muestra. No tenía con qué comparar el modelo completo, así que no sé cuánto cuesta la compresión por sí sola.
Al arrancar, Strata avisó de que en la tarjeta quedaban libres solo 200–450 MB, porque el escritorio ocupa una parte, y sugirió --vram-reserve-mib 1024. Ignoré el aviso y no pasó nada malo, pero cuando el controlador empieza a mover la memoria de la tarjeta a la RAM, la escritura cae a unos pocos tokens por segundo.
Velocidad: mis mediciones frente a la documentación
La documentación da para IQ3_S 53 tokens por segundo de escritura y 1620 tokens por segundo de lectura del prompt, medidos en un ordenador con una RTX 5070 (también de 12 GB), un Ryzen 5 7600 y 64 GB de RAM. En mi máquina, a temperatura 0 (aleatoriedad desactivada, medición repetible) y con cuatro tipos de texto (una función en Python, un ensayo en polaco, un ensayo en inglés, una lista de 30 nombres), Strata escribió de media 49 tokens por segundo: de 43 en el ensayo en polaco a 54 en código. La escritura está, por tanto, al nivel de la documentación. Las diferencias entre tipos de texto se deben a MTP: según las estadísticas que el servidor devuelve con cada respuesta, en código el modelo aceptaba más del 70 % de los tokens propuestos, en prosa polaca alrededor del 40 %.
La lectura de prompts largos salió el doble de lenta que en la documentación: 790–850 tokens por segundo para prompts de 17 a 115 mil tokens. Tengo más núcleos que aquella máquina (22 frente a 6), pero al leer, Strata envía expertos a la tarjeta por PCIe, y mi ordenador tiene PCIe 3.0 (medido en 10,5 GB/s), memoria DDR4 y un procesador sin las instrucciones AVX-512 que el motor usa en procesadores más nuevos (en el mío, según el registro, usó AVX2). La documentación no separa el efecto de estos factores, así que no puedo decir cuál explica la diferencia.
Para comparar, el mismo fichero del modelo en llama.cpp (versión b10809, con los expertos en RAM y sin la capa MTP, que llama.cpp no usa para este modelo) escribía 16 tokens por segundo, tres veces más lento, y leía los prompts a 88–226 tokens por segundo.
Contexto largo
El modelo admite de forma nativa 262 144 tokens de contexto; el instalador fija 32K para tarjetas de menos de 14 GB, yo arranqué Strata con 128K. Para las mediciones tomé fragmentos aleatorios de la documentación inglesa de Strata, distintos cada vez, para que el motor no aprovechara un prompt recordado. Leer 115 mil tokens tardó 140 s, y la escritura apenas dependió de la longitud del contexto: 46 tokens por segundo con 1300 tokens y 42 con 115 mil (43–54 en los prompts cortos de la sección anterior).
Una frase en polaco con una contraseña escondida en el medio la encontró el modelo en 15 de 16 intentos; una vez, con 66 mil tokens, se negó, porque tomó la frase por una inyección de prompt, una instrucción escondida en los datos. En una prueba más difícil coloqué dos frases en inglés al estilo de la documentación («las pruebas nocturnas de regresión se ejecutan en la máquina ORCA-7», «la máquina ORCA-7 está en la oficina de Fráncfort») a un cuarto y a tres cuartos del texto, en cinco prompts de 9 a 122 mil tokens; a la pregunta de en qué ciudad está la máquina de las pruebas nocturnas, el modelo respondió correctamente todas las veces.
Agentes
El comando strata connect imprime o guarda la configuración para Claude Code, Codex CLI, OpenCode, Hermes Agent y algunas herramientas más; para Claude Code son tres variables de entorno: una dirección local compatible con la API de Anthropic, el nombre del modelo y una clave de relleno. Con --check envía una pregunta de prueba y una llamada a herramienta (tool calling, la petición del modelo de ejecutar una función); en mi máquina ambas pasaron en 3–4 segundos.
Claude Code (en modo --bare, sin plugins) recibió de mí un pequeño proyecto en Python con un error en el recuento de palabras, una función sin implementar y seis pruebas, cinco de ellas fallidas. Lo arregló todo en 19 pasos y 133 segundos sin tocar el fichero de pruebas; el modelo formuló correctamente cada llamada a herramienta al primer intento. Ayuda la caché de prompts: el motor recuerda el comienzo ya leído de la conversación, así que en los pasos siguientes leía solo la parte añadida, en 0,3–1,1 s. Es un único intento en una tarea sencilla, no una evaluación del trabajo con un repositorio mayor.
Mi propio benchmark
Los resultados de benchmarks publicados dicen poco de un modelo comprimido a 3 bits, ejecutado en un hardware así y preguntado en polaco. Así que construí mi propio conjunto: 53 tareas en polaco en ocho categorías, que corresponden a lo que miden los conjuntos de prueba públicos para modelos de lenguaje.
| Categoría | Modelo público | Ejemplos de tareas | Tareas |
|---|---|---|---|
| Matemáticas | GSM8K, MATH | multiplicar números grandes, descuento más impuesto, interés compuesto, días entre fechas | 7 |
| Programación | HumanEval, MBPP | funciones en Python ejecutadas contra mis pruebas: validar el número fiscal polaco NIP con su dígito de control, números romanos, números en palabras polacas | 6 |
| Razonamiento | BBH, ARC | un acertijo de mentirosos, pesar monedas, orden por estatura, contar letras en una palabra | 9 |
| Conocimientos | MMLU, SimpleQA | hechos de historia, ciencia e informática, dos de ellos polacos | 7 |
| Seguimiento de instrucciones | IFEval | solo JSON, solo mayúsculas, exactamente cinco líneas, 40–60 palabras con una última palabra impuesta | 7 |
| Trabajo con texto | DROP, SQuAD | preguntas sobre un informe de incidente dado: duración, causa, cronología; el tono de unas reseñas | 6 |
| Redacción | evaluación manual | un correo a un cliente, un poema de cuatro versos con rima AABB, un cuento infantil, un aviso oficial reescrito en tono informal | 6 |
| Resistencia a inventar | TruthfulQA | preguntas sobre cosas que no existen: la novela «El jardín de cristal» de Bolesław Prus (escritor polaco del siglo XIX), un Nobel de Física polaco de 1978, la función de Python itertools.chunked | 5 |
En las seis primeras categorías las respuestas las comprueba un script: compara un número o una palabra, analiza JSON, cuenta líneas y palabras y ejecuta el código contra las pruebas. Las tareas de redacción y de inventar las evalué yo mismo, con dos reglas. Un texto aprueba cuando hace lo que se pidió y es coherente; un único error de lengua no lo descalifica, pero un poema sin rimas o con dos versos en lugar de cuatro, sí. Una respuesta sobre algo inexistente aprueba solo cuando el modelo dice que no existe y no añade hechos inventados; «Prus no lo escribió, es una novela de Reymont» no aprueba.
El conjunto es pequeño y monolingüe, y las tareas las escribí yo, así que mide tareas cotidianas y comprobables en polaco, no los límites de los modelos. Los modelos respondieron con las temperaturas por defecto de sus fichas, es decir, tal como se usan a diario, así que las respuestas varían entre pasadas; por eso repetí el conjunto y sumo los resultados de todas las pasadas: Strata y gemma-4-E4B tres veces sin razonamiento y dos con él, gemma-4-12B y Qwen3.6-35B-A3B dos veces sin y una con, Qwen3.6-27B dos veces sin razonamiento. En el modo de razonamiento, en el que el modelo escribe su razonamiento antes de responder, tuvo para ello un presupuesto de 8000 tokens (Strata) o 6000 (los demás, por ser más lentos); Qwen3.6-27B, a sus 5 tokens por segundo, necesitaría más de diez horas para una pasada así, de modo que lo omití.
Para la comparación elegí cuatro modelos abiertos que en un ordenador con una tarjeta de 12 GB y mucha RAM son la elección natural, todos ejecutados mediante llama.cpp en variantes Q4_K_M (unos 4,8 bits por peso):
- gemma-4-E4B (5 GB): el modelo pequeño de Google, cabe entero en la tarjeta.
- gemma-4-12B (7,4 GB): el mayor de estos modelos que cabe entero en una tarjeta de 12 GB.
- Qwen3.6-35B-A3B (21 GB): un modelo mixture of experts con 3000 millones de parámetros activos; como en Strata, los expertos están en la RAM y los calcula el procesador.
- Qwen3.6-27B (17 GB): un modelo denso, es decir, que calcula todos sus pesos en cada token; en la tarjeta cabe solo en parte.
La comparación no es del todo justa: los modelos pequeños tienen los pesos guardados con unos 4,8 bits, Strata con 3,3, así que si la compresión estropea algo, estropea más el modelo de 125B.
Resultados
Sin el modo de razonamiento, Qwen3.8-Flash-Next a través de Strata respondió correctamente en el 89 % de los intentos (142 de 159 en tres pasadas), y el conjunto completo de 53 tareas le llevó 3,3 minutos. Gemma-4-12B obtuvo el 82 %, Qwen3.6-35B-A3B el 79 %, gemma-4-E4B el 63 % y Qwen3.6-27B el 79 %.
Matemáticas y programación son lo que más separa al modelo grande de los pequeños. Strata falló una vez en 21 intentos de matemáticas (en el problema de los trenes dio 20 minutos en vez de 120) y ninguna en 18 intentos de programación; gemma-4-12B y Qwen3.6-35B-A3B tuvieron 11 y 10 de 14 en matemáticas y 10 de 12 cada uno en código. La función que escribe números en palabras polacas, con la flexión «dwa tysiące», «pięć tysięcy», no la superó ninguno de los modelos pequeños en ninguna pasada, y la multiplicación 4567 × 8912 la fallaron todas las veces sin razonamiento tres de los cuatro modelos pequeños (solo Qwen3.6-27B la resolvió); con razonamiento también la calculó gemma-4-12B. Gemma-4-E4B aprobó 7 de 18 tareas de código; sus funciones para analizar duraciones, validar números NIP y escribir números en palabras no pasaron las pruebas en ninguna pasada.
Razonamiento le salió flojo a Strata sin razonamiento: 23 de 27. El acertijo sobre tres personas de las que algunas siempre mienten lo falló en los tres intentos, respondiendo cada vez en menos de un segundo con un solo nombre; con razonamiento lo resolvió dos de dos veces. Sin razonamiento, todos los modelos pequeños fallaron también ese acertijo en todas las pasadas. Contar las letras «r» en la palabra «przerażający» es una trampa de tokenización (el modelo ve la palabra en trozos, no en letras), que Strata superó 2 de 3 veces y las dos Gemma ninguna.
Conocimientos y seguimiento de instrucciones no distinguen a los modelos mayores: Strata, gemma-4-12B y Qwen3.6-35B-A3B tuvieron aquí pleno o casi pleno. Gemma-4-E4B se equivocó en hechos en 6 de 21 intentos y no cumplió ni una vez la instrucción «responde solo en mayúsculas». Qwen3.6-35B-A3B superó dos veces el límite impuesto de 40–60 palabras.
Trabajo con texto es la única categoría en la que Strata sin razonamiento perdió frente a los modelos pequeños: 15 de 18 frente al pleno de gemma-4-12B y Qwen3.6-35B-A3B. Toda la diferencia es una pregunta: la duración del incidente, a la que tres veces respondió 105 minutos, contando desde la caducidad del certificado (14:30) en lugar de desde el momento en que el sistema dejó de aceptar transacciones (14:35). Con razonamiento tuvo pleno.
Redacción la evalué a mano. El correo, la explicación técnica, la traducción de modismos y el aviso reescrito le salieron bien a Strata en todos los intentos; el poema de cuatro versos con rima AABB no le salió sin razonamiento ni una vez (una vez recibí dos versos en lugar de cuatro), y con razonamiento, dos de dos. Rimar en polaco resultó difícil para todos: ninguno de los modelos pequeños escribió un cuarteto correcto, y las Gemma metían en los poemas palabras inexistentes («gotę», «rozwoni»). Qwen3.6-35B-A3B añadió dos veces al aviso reescrito que la formación es «el miércoles» (el 3 de junio de 2024 fue lunes).
Resistencia a inventar la perdieron todos los modelos. Strata sin razonamiento aprobó 9 de 15 intentos, con razonamiento 3 de 10; gemma-4-12B y Qwen3.6-35B-A3B 4 de 10 cada uno, gemma-4-E4B 5 de 15, y el mejor fue Qwen3.6-27B con 6 de 10. Pocas veces se trató de resumir desde cero una novela inexistente (aunque gemma-4-E4B lo hizo todas las veces). El error típico era otro: el modelo negaba con razón y luego añadía hechos inventados, por ejemplo que «El jardín de cristal» lo escribió Reymont (otro escritor polaco, premio Nobel), que «Sombras de puentes» es una novela de John le Carré de 2015, o caía en un bucle de «Jerzy Zurek (no, es un error)» repetido hasta el final de la respuesta. Diez intentos de Strata con razonamiento son pocos para hablar de una regla, pero el patrón fue el mismo cada vez: tras un razonamiento más largo el modelo respondía con más seguridad, no con más verdad, y por ejemplo dos de dos veces describió, con un ejemplo de código, la función itertools.chunked, que Python no tiene.
El razonamiento ayuda, pues, donde hay que calcular o comprobar: a Strata le subió el resultado del 89 % al 92 %, y a gemma-4-E4B del 63 % al 77 %. A cambio cuesta tiempo: el conjunto le llevó a Strata más de cinco veces más (18,4 minutos en lugar de 3,3), y una función en Python tardó 141 s y 6783 tokens de razonamiento más respuesta en lugar de 22 s. Gemma-4-12B razonó durante 26 minutos y en tres tareas agotó el presupuesto de 6000 tokens, entregando, entre otras cosas, un poema vacío. Qwen3.6-35B-A3B con razonamiento quedó igual que sin él (77 % frente a 79 %), porque en nueve tareas, cuatro de ellas de código, agotó el presupuesto y no llegó a responder, y el conjunto duró 65 minutos. El presupuesto es elección mía; con uno mayor estos modelos responderían seguramente mejor, pero aún más despacio.
Qwen3.6-27B, el único modelo denso de la comparación, respondió correctamente en el 79 % de los intentos (84 de 106), pero a 5 tokens por segundo el conjunto le llevó 28 minutos, casi nueve veces más que a Strata sin razonamiento. Fue el único de los modelos pequeños que calculó bien la multiplicación en ambas pasadas y el mejor de los cinco en las preguntas sobre cosas inexistentes, pero falló dos veces el año de publicación de «La muñeca» y el planeta con más lunas, y nunca resolvió el acertijo de los mentirosos ni los números en palabras.
Qué se desprende de esto
La velocidad en este ordenador la deciden tres cosas: cuántos pesos calcula el modelo por token, si caben en la tarjeta y si el motor tiene predicción de varios tokens. Gemma-4-E4B escribe 76 tokens por segundo, gemma-4-12B 38, Qwen3.6-35B-A3B con los expertos en RAM 37, Strata 49, y Qwen3.6-27B, que no cabe en la tarjeta, 5; el mismo modelo de 125B sin MTP en llama.cpp escribía 16. En una tarjeta de 12 GB la elección se reduce al par Strata o gemma-4-12B: 7 puntos porcentuales y 11 tokens por segundo más, con los mismos errores al inventar, a cambio de 60 GB de RAM ocupados todo el tiempo que funciona, 90 GB de disco y la dependencia del motor de un solo autor, construido en torno a una sola familia de modelos. Cuando salga el próximo Qwen, llama.cpp lo soportará en días; Strata, cuando Niko1221 lo añada.
La posibilidad de hacer parte del trabajo por completo en local, con un modelo menor que los principales modelos en la nube, es tentadora, y tras esta prueba sé qué parte: cálculos, código, preguntas sobre hechos comprobables y trabajo con documentos. Preguntas sobre cosas que el modelo quizá no conozca no se las haría en local a ninguno de los cinco modelos sin comprobar la respuesta.
El dinero no es aquí el argumento. Bajo carga el ordenador consumía según el vatímetro unos 340 W, de los que la tarjeta sola unos 140 W; al precio de la electricidad en Polonia, alrededor de 1 esloti por kilovatio hora, una hora de trabajo del modelo cuesta unos 0,35 eslotis (8 céntimos de euro). El mismo modelo en la API de Alibaba cuesta, según las listas de precios de los agregadores, 0,47 dólares por millón de tokens generados, y en una hora Strata genera como mucho 176 mil; es el mismo orden de magnitud, sin comprar 60 GB de RAM. El argumento son los datos que no salen del ordenador, la ausencia de límites y el trabajo sin red. La limitación es que Strata atiende por defecto una petición a la vez (no probé con varios usuarios) y que el modo de razonamiento, que mejora los resultados en lógica y código, multiplica por cinco el tiempo de trabajo.
Fuentes
- Strata, repositorio y documentación, Niko1221, versión 0.2.3, motor 0.1.48: README (tabla de velocidades),
docs/MODELS.md,docs/QUANTS.md,docs/HOW_IT_WORKS.md. - Qwen3.8-Flash-Next, ficha del modelo, Qwen.
- llama.cpp, ggml-org, versión b10809; modelos de comparación en variantes Q4_K_M de LM Studio Community.
- Precio de la API de Qwen3.8-Flash-Next según anotherwrapper.com, a septiembre de 2026.