Un modelo de 125B en una RTX 3060, siempre que haya mucha RAM. Pruebo Strata

Strata ejecuta Qwen3.8-Flash-Next, un modelo de 125 mil millones de parámetros, en un equipo con una sola tarjeta gráfica. Es un motor abierto con licencia MIT, publicado por un autor con el seudónimo Niko1221 y sin relación con el equipo de Qwen. Basta una tarjeta de 12 GB porque la mayor parte del modelo reside en la RAM: con una tarjeta así, la variante probada necesita, según la documentación, unos 60 GB de RAM, y en la práctica 64 GB. La probé en un equipo con una GeForce RTX 3060 (12 GB), un procesador Intel Xeon E5-2699 v4 de 2016 y 121 GB de RAM.

En ese equipo, Strata escribía las respuestas a 43–54 tokens por segundo, más despacio en polaco, y leía prompts largos a unos 800 tokens por segundo. El mismo archivo del modelo en llama.cpp, con los expertos en la RAM, escribía 16 tokens por segundo y leía como máximo 226. En 17 tareas verificables en polaco, Strata sin modo de razonamiento respondió correctamente en el 88 % de los intentos, y con razonamiento, en el 97 %. Dos modelos más pequeños que ejecuté en el mismo equipo para comparar, gemma-4-E4B y Qwen3.6-27B, respondieron correctamente en el 41–71 % de los intentos e inventaban datos.

Cómo caben 125 mil millones de parámetros en 12 GB

Qwen3.8-Flash-Next es un modelo de tipo mixture of experts (MoE). Cada una de sus 48 capas tiene 512 «expertos», es decir, bloques independientes de la red, y el router, una pequeña red al inicio de la capa, elige para cada token 10 de ellos más un experto compartido. Según la ficha del modelo, con cada token trabajan unos 6 mil millones de parámetros, menos del 5 % del total. El resto de los pesos no tiene que estar en la tarjeta gráfica; solo tiene que estar disponible con la rapidez suficiente.

La ficha del modelo cuenta 125 mil millones de parámetros de la red propiamente dicha y les suma dos componentes, hasta un total de 180 mil millones en los archivos. El primero es una tabla de embeddings de n-gramas (51 mil millones de parámetros): vectores numéricos ya calculados para 20 millones de pares y tríos de tokens frecuentes, que el modelo lee en la segunda capa en lugar de calcularlos. El segundo es la capa MTP (multi-token prediction, 4 mil millones de parámetros), que describo más abajo.

Strata reparte todo esto en tres niveles de memoria:

La tarjeta gráfica guarda las capas de atención (las partes de la red que comparan el token actual con el texto anterior), los routers, los expertos compartidos, la caché del contexto (KV cache) y una reserva con los expertos más usados. En mi tarjeta cupieron 1891 (3,9 GB), es decir, el 8 % del total. Aun así, en las consultas de mis pruebas el 55–69 % de los expertos elegidos por el router ya estaba en la tarjeta; el motor los va intercambiando mientras trabaja, y en la primera consulta tras el arranque solo el 29 % estaba en la tarjeta.
La RAM guarda los 24 576 expertos, que en la variante probada ocupan 50 GB. Cuando un experto no está en la tarjeta, lo calcula el procesador, en paralelo con la tarjeta. En mi caso lo hacían 20 de los 22 núcleos (Strata deja uno para el sistema y en otro corre el hilo de control), con instrucciones AVX2, porque este procesador no tiene AVX-512.
El disco SSD guarda la tabla de n-gramas (29 GB). El modelo lee de ella unas pocas filas por token. Sin embargo, cuando la RAM es muy grande (para esta variante, a partir de 107 GB según la documentación), Strata en Linux la carga en memoria, porque según sus mediciones eso acorta la lectura del prompt un 18 % con 4 mil tokens y un 2 % con 98 mil. Así ocurrió en mi caso, y por eso el proceso del motor ocupaba 83 GB de RAM.

Los pesos están comprimidos mediante cuantización, es decir, guardando los números con menos bits. El nombre de la variante, IQ3_S, designa un esquema de compresión en el que cada experto ocupa de media unos 3,3 bits por peso en lugar de 16. Los autores de Strata escriben que esta variante «rinde igual que el modelo completo en las pruebas publicadas», pero no indican de qué pruebas se trata. Las cifras proceden de su propia medición sobre 5 mil tokens de texto (código, documentación y prosa en varios idiomas): IQ3_S elige el mismo token siguiente más probable que la variante de 8 bits en el 87,7 % de las posiciones, y la perplexity, una medida de cuánto le sorprende el texto al modelo, sube de 4,052 a 4,097, alrededor de un 1 %. Un token distinto no tiene por qué cambiar el sentido de la respuesta, pero la documentación no muestra con qué frecuencia lo cambia.

La capa MTP propone hasta tres tokens siguientes, y el modelo completo los verifica en una sola pasada y conserva los acertados. Es una variante de la decodificación especulativa: la respuesta es la misma, solo que llega antes. En tarjetas de 12–16 GB, Strata además omite por defecto los expertos que se eligen con poca frecuencia y que en ese momento no están en la tarjeta. Según la documentación, en la RTX 3060 el modelo elige entonces el mismo token más probable que con el cálculo exacto en el 97,7 % de las posiciones. Todas mis pruebas de calidad se hicieron con este ajuste; no medí su efecto en los resultados de las tareas, solo cuánta velocidad aportan ambas aceleraciones (más abajo).

El proyecto de Dan Woods, que ejecutó Qwen 397B en un MacBook [Polski] con 48 GB de memoria, leía los expertos sobre la marcha desde el disco. Strata los mantiene en la RAM: necesita mucha más, pero no tiene que esperar al disco.

Cuánta memoria hace falta

Strata ejecuta el mismo modelo con varios niveles de compresión. El instalador suma la RAM a la memoria de la tarjeta, resta 5 GB para el sistema y, según el resultado, propone una variante:

Umbral del instalador (RAM + VRAM − 5 GB)	Variante	Ocupa (RAM + VRAM)	Notas
32 GB	Coder IQ1_M	aprox. 32 GB	la mitad de los expertos, elegidos para programación; más débil fuera del código
40 GB	IQ2_XS	39,2 GB
48 GB	IQ3_XXS	47,0 GB
64 GB	IQ3_S	54,8 GB	la más lenta y la más precisa de las variantes de 2–3 bits; la que probé aquí

Los tamaños de la tabla no incluyen la tabla de n-gramas, que por defecto se queda en el disco. El umbral es mayor que la memoria ocupada porque los expertos tienen que caber solo en la RAM: la documentación recomienda una RAM igual al tamaño de los expertos más unos 10 GB, es decir, unos 60 GB para IQ3_S. Con una tarjeta de 12 GB, el umbral de 64 GB equivale a 57 GB de RAM, y la documentación indica que con 64 GB de RAM IQ3_S funciona si hay pocos programas abiertos. En los equipos con memoria compartida entre el procesador y la gráfica, como un Mac con procesador de Apple, lo que cuenta es su tamaño total.

Con un umbral de 96 GB o más también están disponibles variantes de 4–8 bits preparadas por Unsloth, una empresa que publica versiones comprimidas de modelos abiertos: desde UD-IQ4_XS (94 GB de descarga; los expertos ocupan unos 72 GB de RAM) hasta Q8_0 (188 GB de descarga, unos 136 GB de RAM para los expertos). Aun así, el instalador sigue proponiendo IQ3_S y la variante mayor hay que elegirla a mano; yo me quedé con IQ3_S.

La tarjeta debe tener al menos 12 GB de memoria (NVIDIA desde la serie RTX 20, Radeon recientes, Intel Arc) y el procesador debe admitir AVX2. Una tarjeta mayor acelera el modelo, porque caben en ella más expertos, pero no reduce la RAM necesaria.

El modelo admite de forma nativa 262 144 tokens de contexto. El instalador fija 32K para tarjetas de menos de 14 GB, pero el límite se puede subir al arrancar. A partir de 64K, Strata guarda la mayor parte de la memoria del contexto en la RAM y deja en la tarjeta solo una ventana de 32K. Con los 128K que configuré, eso ocupaba 1,7 GB de RAM, y el uso de memoria de la tarjeta no cambió.

Instalación en Ubuntu

Elegí la instalación mediante el comando strata en la terminal, que no requiere permisos de administrador:

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 de instalación comprueba el hash SHA-256 del paquete y la firma de la versión publicada, y lo guarda todo en el directorio personal. La descarga del motor y del modelo con sus complementos (90 GB en total) llevó unas 3 horas y 20 minutos a 4–9 MB/s. La carga del modelo tarda alrededor de un minuto. El servidor ofrece una API compatible con OpenAI (http://127.0.0.1:8080/v1) y con Anthropic (http://127.0.0.1:8080), además de un chat en el navegador.

Al arrancar, Strata advirtió que en la tarjeta quedaban solo 200–450 MB de memoria libre, porque parte la ocupa el escritorio, y sugirió --vram-reserve-mib 1024. Con la tarjeta tan llena, el controlador puede trasladar memoria de la GPU a la RAM, y entonces la escritura cae a unos pocos tokens por segundo. En mis pruebas no llegó a ocurrir.

Condiciones de las mediciones

Ubuntu 26.04.1, kernel 7.0, controlador NVIDIA 595.99, Strata 0.2.3 con el motor 0.1.48 para CUDA 13, variante IQ3_S, contexto de 128K, escritorio gráfico activo.
RAM DDR4 (el Xeon E5 v4 tiene cuatro canales de memoria), tarjeta en PCIe 3.0 x16; Strata midió una transferencia a la tarjeta de 10,5 GB/s.
Las velocidades proceden del campo timings de las respuestas del servidor; Strata y llama.cpp las reportan del mismo modo. La velocidad de escritura incluye los tokens aceptados de MTP. El porcentaje de expertos en la tarjeta, el tamaño de su memoria y el número de núcleos figuran en el log del motor.
Strata y llama.cpp cuentan los tokens igual: el mismo texto dio 7911 y 7922 tokens respectivamente (la diferencia es la plantilla de chat), así que las velocidades en tokens por segundo son comparables.

Velocidad de escritura y qué la aumenta

Cuatro instrucciones: una función en Python, un ensayo en polaco y otro en inglés (de unas 400 palabras cada uno) y una lista de 30 nombres con su justificación. Envié cada una dos veces, con temperatura 0, tras un arranque limpio del servidor; la tabla muestra la media de ambas pasadas en tokens por segundo:

Configuración	código	ensayo PL	ensayo EN	lista
Strata, ajustes por defecto	53,8	42,9	50,3	49,2
Strata sin MTP	40,3	42,4	42,1	42,2
Strata sin omitir los expertos poco frecuentes	45,5	37,8	43,2	43,1
llama.cpp, todos los expertos en la RAM (`--cpu-moe`)	15,6	15,6	15,6	15,7
llama.cpp, expertos de 2 capas en la tarjeta (`--n-cpu-moe 46 -ub 2048`)	15,9	16,0	16,0	15,9

En el uso normal, con las temperaturas por defecto (0,7 sin razonamiento y 1,0 con razonamiento), Strata escribía a un ritmo parecido: en las pruebas de calidad, la mediana para respuestas de más de 150 tokens fue de 52 tokens por segundo sin razonamiento y de 49,5 con razonamiento.

MTP acelera la escritura de código en un tercio, la de prosa en inglés y la de la lista en un 17–19 %, y la de prosa en polaco casi nada (1 %). En el texto polaco el modelo aceptaba alrededor del 40 % de los tokens propuestos, y en el código, más del 70 %; además, verificar las propuestas rechazadas también lleva tiempo. La documentación de Strata promete entre 1,6 y 1,8 veces más velocidad; con este hardware y estos textos la ganancia fue menor. Omitir los expertos poco frecuentes aportó un 13–18 %, en línea con la documentación.

Llama.cpp (versión b10809) cargó el mismo archivo sin cambios, pero escribía tres veces más despacio. En esta configuración no usaba la capa MTP y los expertos los calculaba el procesador. Pasar a la tarjeta los expertos de dos capas y procesar el prompt en lotes de 2048 tokens (parámetros -ub y -b) apenas cambió la escritura; no cabían más capas en la tarjeta.

Contexto largo

Para medir el contexto usé un fragmento aleatorio de la documentación de Strata en inglés, de entre 1000 y 115 mil tokens, distinto cada vez, para que el motor no reutilizara un prompt guardado antes. En el medio insertaba una frase en polaco con una contraseña y pedía la contraseña y una frase sobre el contenido de la documentación. Medí seis longitudes dos veces cada una, y cuatro de ellas una vez más pidiendo un resumen más largo: 16 intentos en total.

La lectura del prompt, es decir, el prefill, tardó desde 4 s con 1000 tokens hasta 140 s con 115 mil. A partir de unos 17 mil tokens, la velocidad fue de 790–850 tokens por segundo; con prompts cortos es menor porque domina una sobrecarga fija. Llama.cpp leía el mismo tipo de texto a 85–91 tokens por segundo, y con lotes de 2048 tokens, a 226. Al leer el prompt, Strata envía los expertos a la tarjeta por PCIe, así que el PCIe 3.0 es probablemente aquí el eslabón más lento. La documentación de Strata indica, para una RTX 5070 con un procesador Ryzen 5 7600, unos 1620 tokens por segundo con un prompt de 32K, el doble que en mi equipo. Sin embargo, aquel equipo también tiene otro procesador y otra memoria, y la medición se hizo con una versión anterior del motor, así que no se puede determinar la causa de la diferencia.

La escritura casi no dependía de la longitud del contexto: con un resumen de 500 tokens, 46 tokens por segundo con 1,3 mil tokens de contexto y 42 con 115 mil. Solo 12 de las 48 capas del modelo son capas de atención, e incluso estas leen para cada token un número limitado de bloques del contexto (hasta 2048 tokens según la ficha del modelo). Las 36 capas restantes (Gated DeltaNet) no recorren el contexto, sino que actualizan un estado de tamaño fijo.

El modelo dio la contraseña en 15 de los 16 intentos, también con 115 mil tokens. En un intento, con 66 mil tokens, se negó: consideró que la frase con la contraseña era un intento de prompt injection, es decir, una instrucción oculta en los datos. Pero una frase en polaco dentro de un texto en inglés es fácil de localizar, así que añadí una prueba más difícil, con cinco prompts aparte de entre 9 y 122 mil tokens. Inserté dos frases en inglés al estilo de la documentación, a un cuarto y a tres cuartos del texto: «las pruebas de regresión nocturnas se ejecutan en la máquina ORCA-7» y «la máquina ORCA-7 está en la oficina de Fráncfort». A la pregunta de en qué ciudad está la máquina de las pruebas nocturnas, el modelo respondió correctamente en los cinco intentos.

Calidad de las respuestas

Preparé 20 tareas en polaco, porque quería probar el modelo en un idioma distinto del inglés; en inglés los resultados pueden ser otros. En 17 tareas la respuesta se puede verificar automáticamente: cálculos (una multiplicación, un descuento con IVA, contar días en un año bisiesto), acertijos lógicos, preguntas de datos, una respuesta en formato JSON, una instrucción con varias restricciones a la vez, una pregunta sobre una novela inexistente de Bolesław Prus (escritor polaco del siglo XIX, autor de «Lalka» [La muñeca]) y tres funciones en Python que ejecuté con tests. La más difícil escribe con palabras en polaco los números del 0 al 999 999; los numerales polacos cambian de forma según el número («dwa tysiące» [dos mil], «pięć tysięcy» [cinco mil]), y la instrucción exigía escribir «tysiąc» (mil) en lugar de «jeden tysiąc» (un mil). Tres tareas (una explicación técnica, un correo a un cliente y la traducción de modismos) las evalué leyendo las respuestas.

Strata usa por defecto las temperaturas de la ficha del modelo, así que las respuestas varían de una pasada a otra. Recorrí la batería sin razonamiento tres veces y con razonamiento, dos. Los modelos de referencia los ejecuté con llama.cpp en variantes Q4_K_M (unos 4,8 bits por peso), con las temperaturas de sus fichas: gemma-4-E4B, tres veces sin razonamiento y dos con razonamiento; Qwen3.6-27B, dos veces y solo sin razonamiento, porque a su velocidad una pasada con razonamiento habría durado, según mi estimación, más de una hora.

Modelo y modo	Respuestas correctas en 17 tareas	Tiempo de la batería completa (20 tareas)
Strata, Qwen3.8-Flash-Next, sin razonamiento (3 pasadas)	45 de 51 (88 %)	83–96 s
Strata, Qwen3.8-Flash-Next, con razonamiento (2 pasadas)	33 de 34 (97 %)	412–534 s
gemma-4-E4B, sin razonamiento (3 pasadas)	21 de 51 (41 %)	78–88 s
gemma-4-E4B, con razonamiento (2 pasadas)	21 de 34 (62 %)	215–216 s
Qwen3.6-27B, sin razonamiento (2 pasadas)	24 de 34 (71 %)	658–690 s

Sin razonamiento, Strata falló en cuatro tareas, sobre todo en dos. El acertijo de tres personas, algunas de las cuales siempre mienten, lo resolvió una vez de cada tres, y cada vez respondió en menos de un segundo. La función que escribe los números con palabras no pasó los tests en dos de los tres intentos: una vez escribió «jeden tysiąc», aunque la instrucción exigía explícitamente «tysiąc», y otra vez se le perdió la palabra «tysięcy» (miles). En una pasada también se equivocó en el resultado de la multiplicación (40 701 304 en lugar de 40 701 104), y la función que convierte la notación «1h 30m 15s» a segundos rechazaba las mayúsculas, aunque la instrucción pedía aceptarlas. Con razonamiento, el único error fue de nuevo «jeden tysiąc». A la pregunta sobre «Szklany ogród» (El jardín de cristal) de Prus, el modelo respondió en los cinco intentos que esa novela no existe.

El razonamiento cuesta mucho tiempo. La batería duró cinco veces más, y lo que más tardaba eran las tareas de programación sencillas: la función de duraciones mencionada antes costó 101 s y 4712 tokens en lugar de 6 s, con el mismo resultado en los tests.

Gemma-4-E4B (5 GB) cabe entera en la tarjeta y escribe 75 tokens por segundo, una vez y media más rápido que Strata. Sin razonamiento respondió correctamente en 21 de 51 intentos, y con razonamiento, en 21 de 34. En las cinco pasadas falló la multiplicación, el conteo de letras y la pregunta sobre el sistema en el que se desarrolló Linux, y cada vez inventó el argumento de la novela inexistente de Prus, siempre con un protagonista distinto. En la primera pasada sin razonamiento, el límite de 1200 tokens cortó dos de sus respuestas de programación, porque el modelo añadía al código sus propios tests.

Qwen3.6-27B (17 GB) es un modelo denso, es decir, con cada token calcula todos los pesos. En una tarjeta de 12 GB parte de ellos se queda en la RAM, así que escribía 5 tokens por segundo y la batería duró 11 minutos. Respondió correctamente en 24 de 34 intentos. En ambas pasadas falló el año de publicación de «Lalka» (La muñeca), el acertijo de los mentirosos y la función de los números con palabras. A la pregunta sobre «Szklany ogród», las dos veces respondió que Prus no lo escribió, pero añadía datos inventados; por ejemplo, atribuyó a Prus «W pustyni i w puszczy» (En el desierto y en la selva), una novela de Henryk Sienkiewicz.

El fabricante indica para el modelo completo Qwen3.8-Flash-Next, entre otros, 91,7 en GPQA Diamond y 62,5 en SWE-bench Pro; son resultados de Qwen para el modelo sin comprimir, que mi batería no comprueba.

Claude Code y otros agentes

El comando strata connect muestra y guarda la configuración para OpenCode, Codex CLI, Claude Code, Hermes Agent (un agente open source de Nous Research), OpenClaw y algunas herramientas más. Con la opción --check envía una pregunta y una llamada a una herramienta (tool calling, es decir, una petición del modelo para ejecutar una función) tal como lo hace cada aplicación. Para Claude Code y Hermes Agent, ambas comprobaciones pasaron en 3–4 segundos.

Le di una tarea real a Claude Code (versión 2.1.310, en modo --bare, es decir, sin plugins ni servidores MCP): un pequeño proyecto en Python con un error en el conteo de palabras, una función top_words sin implementar y seis tests, de los que cinco fallaban. El agente ejecutó los tests, corrigió el error, escribió la función y volvió a ejecutar los tests. Le llevó 19 pasos y 133 segundos; todos los tests pasaron y el archivo de tests quedó intacto. En el código quedó una incoherencia: una función auxiliar está anotada como si devolviera una lista, pero devuelve un generador. Es un solo intento con una sola tarea sencilla, no una evaluación del trabajo con un repositorio más grande.

El primer paso envió 4,6 mil tokens de prompt de sistema y descripciones de herramientas, que Strata leyó en 6,3 s. En los pasos siguientes, el 95–99 % del prompt ya estaba guardado, así que el motor solo leía el fragmento añadido, en 0,3–1,1 s, aunque la conversación creció hasta 8,3 mil tokens. Strata guarda en la RAM los prompts ya leídos de varias conversaciones (en mi caso, hasta 8 GB), pero las atiende de una en una: por defecto responde a una sola consulta a la vez. Según la documentación de Strata, el prompt completo de Claude Code sin el modo --bare tiene 15,6 mil tokens, y el de Hermes Agent, 12,9 mil, por lo que para trabajar con agentes conviene subir el contexto desde los 32K por defecto.

Cuándo compensa

Poder hacer parte del trabajo de forma totalmente local, con un modelo más pequeño que los principales modelos en la nube, resulta tentador, y esta prueba muestra lo que hace falta para ello. Gemma-4-E4B, que cabe entera en la tarjeta, era la que respondía más rápido, pero falló en más de la mitad de los intentos e inventaba datos. Qwen3.8-Flash-Next con Strata respondió correctamente sin razonamiento en el 88 % de los intentos, a 43–54 tokens por segundo, y con razonamiento, en el 97 %, aunque entonces la batería duró cinco veces más. A cambio, requiere unos 60 GB de RAM y casi toda la tarjeta. Qwen3.6-27B, un modelo denso que no cabe en la tarjeta, obtuvo peores resultados que Strata y fue diez veces más lento: en esta comparación, la velocidad dependía de cuántos pesos hay que calcular por token, no del tamaño total del modelo.

Así que, en un equipo con mucha RAM, un modelo local tiene sentido con datos que no quiero enviar a la nube, para buscar información en documentos largos (lee 115 mil tokens en unos 2,5 minutos), para tareas de programación más sencillas y con agentes que en cada paso añaden poco a la conversación. Funcionará peor cuando varias personas usen el servidor a la vez, cuando la tarjeta gráfica haga falta para otra cosa o cuando cada tarea requiera razonamiento. No hay que pagar por tokens, pero el equipo bajo carga consume electricidad: solo la tarjeta consumía unos 140 W al escribir; el consumo del equipo completo no lo medí.

Fuentes

Strata, repositorio y documentación, Niko1221, versión 0.2.3, motor 0.1.48: README, docs/MODELS.md, docs/DETAILS.md, docs/QUANTS.md, docs/HOW_IT_WORKS.md.
Qwen3.8-Flash-Next, ficha del modelo, Qwen.
llama.cpp, ggml-org, versión b10809.
Hermes Agent, Nous Research.