Meta Muse Glimmer: 30B agéntico local que siempre está ahí

Si vienes siguiendo el tema de los modelos locales, hace poco cubrimos cómo correr LLMs en tu máquina con Ollama y el caso extremo de Swiftlet 80B en 4GB. Los dos posts comparten una conclusión: el ecosistema open se pone más interesante cada trimestre, pero la mayoría de los modelos que aparecen son chatbots disfrazados de "agentes". El 10 de agosto Meta Superintelligence Labs publicó Muse Glimmer y la historia cambia: por primera vez un lab grande pone como caso de uso principal, no secundario, un agente que vive en local, todo el tiempo, orquestando herramientas.

La nota coincidió con una columna de Financial Times donde Zuckerberg critica a los rivales "cerrados" y oficializa el regreso de Meta a los pesos abiertos. Es lectura recomendada para entender el contexto, pero el plato fuerte técnico está en el paper y en los pesos.

Qué es Muse Glimmer en una línea

Un modelo de 30 mil millones de parámetros con pesos abiertos bajo Apache 2.0, entrenado específicamente para workflows agénticos que corren en una Mac o en un PC con una sola GPU de consumo. No es un chatbot más: la optimización apunta a ejecución de largo horizonte, tool calling preciso, memoria de contexto largo, manejo de errores, multimodalidad y razonamiento multi-step. Todo eso a la vez, sin pasar por la nube.

El dato que lo separa del resto: el modelo cuantizado a 4-bit pesa menos de 20 GB y entra en una GPU de 24 GB (RTX 4090 o 3090) o en una Mac con 32 GB de memoria unificada o más. En la misma memoria viven el KV cache, el encoder multimodal y el drafter de speculative decoding. Es un único binario, no un clúster de servicios.

Para los que llegamos a Ollama en su momento, esto es un salto de nivel: no es un modelo pequeño que corre lento, es un modelo serio, agéntico, con tool calling robusto, que cabe en hardware que ya tienes. La diferencia con Swiftlet es que Swiftlet probaba que un modelo de 80B cabe en 4 GB con cuantización agresiva; Glimmer demuestra que con 30B y 4-bit te queda un agente utilizable de verdad.

Por qué importa el "always-on"

Cuando Anthropic, OpenAI o Google presentan un modelo nuevo, el pitch casi siempre es el mismo: "es nuestro modelo más inteligente, corre en nuestra nube, páganos por token". Meta eligió un terreno distinto. El paper dice textualmente que está "optimizado para casos de uso locales, incluyendo agentes always-on, function calling, coding local y evaluación LLM-as-a-judge".

Qué significa always-on en la práctica: un agente que arranca con tu sistema operativo, mantiene una sesión persistente con memoria de largo plazo y está disponible para responderte a ti o a otro programa sin pedirte un token de API por cada llamada. No es una demo de laboratorio: es la pieza que faltaba para correr agentes 24/7 en una workstation sin que la factura de fin de mes te haga llorar.

Esto se conecta con algo que vimos en IA agéntica: consolidación: la mayoría de los frameworks de agentes (LangChain, AutoGen, los SDK de Anthropic y OpenAI) están pensados para correr en la nube con requests HTTP. Cuando el agente corre en local, la discusión cambia: ¿cómo persisto el estado entre reinicios? ¿Cómo manejo la memoria? ¿Cómo monitorizo el uso sin un dashboard del vendor? Glimmer viene con respuestas concretas a esas tres preguntas, y eso lo hace especialmente interesante para quien quiera montar un agente que no dependa de la nube.

El entrenamiento: destilación con un giro

Tres fases que vale la pena mirar, porque cada una ataca un problema distinto de los modelos locales:

Pre-training con destilación de logits. Muse Glimmer se entrenó sobre los outputs de Muse Spark, el modelo más grande de la familia. La diferencia con la destilación clásica es que transfieren los logits completos, no solo las respuestas. Eso preserva información sobre la distribución de probabilidad que el modelo pequeño necesita para mantener capacidad de razonamiento.

Mid-training con datos agénticos. Aquí se hace el grueso del trabajo específico. Mezclan datos de contexto largo, trazas de razonamiento más ricas y datos sintéticos de workflows agénticos. Es la razón por la que Glimmer funciona bien en benchmarks como SWE-Bench, MCP-Atlas y tau-Bench, que miden la capacidad de resolver tareas multi-turno de principio a fin, no solo de responder una pregunta aislada.

Post-training con SFT + RL + destilación on-policy. Tres pérdidas combinadas: supervised fine-tuning, reinforcement learning y destilación on-policy del teacher. El RL es el ingrediente que explica por qué Glimmer se recupera solo cuando una tool call falla en vez de quedarse colgado. Esa capacidad de recuperación fue durante mucho tiempo el talón de Aquiles de los modelos pequeños locales: en cuanto una API devolvía algo raro, el agente se rompía.

Cómo corre en tu máquina

La parte operativa es donde Meta acertó de lleno. La integración con llama.cpp, MLX y ExecuTorch llega en los días siguientes al lanzamiento. Eso significa que si ya usas Ollama (como vimos en como-usar-ollama-para-correr-llms-localmente), la curva de entrada es prácticamente cero. Si usas LM Studio, también: la versión de 18.16 GB ya está disponible en su catálogo.

El truco para que entre todo en 24 GB es una combinación de tres optimizaciones que vale la pena entender:

# Cuantización 4-bit con preservación de attention heads
# En vez de cuantizar de forma uniforme, mantienen las heads críticas
# en fp8 para que la calidad agéntica no caiga
import torch
from transformers import AutoModelForCausalLM, BitsAndBytesConfig

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
    # Saltar las capas críticas para tool calling
    llm_int8_skip_modules=["tool_router", "kv_cache"]
)

Speculative decoding. En vez de generar token a token, un modelo pequeño propone varios tokens y Glimmer los valida en paralelo. En la práctica, esto duplica o triplica la velocidad de respuesta sin perder calidad. Es la pieza que hace que la experiencia "always-on" no se sienta lenta.

Perception encoder multimodal. El modelo acepta imágenes intercaladas con texto. Esto habilita agentes que pueden leer capturas de pantalla, interpretar gráficos o trabajar con documentos. Para un agente local que organiza archivos, es la diferencia entre un chatbot y una herramienta.

Probando Glimmer en local: tres caminos

Dependiendo de tu setup, el camino de instalación cambia. Estos son los tres que probaría esta semana:

Con Ollama (el más rápido). En cuanto Meta publique el GGUF oficial en su Hugging Face, Ollama lo va a tomar del feed. El comando será algo así:

# Cuando el modelo esté publicado en HF
ollama pull muse-glimmer:30b-q4_K_M
ollama run muse-glimmer:30b-q4_K_M

Y para integrarlo como agente, lo levantas como endpoint compatible con OpenAI y lo conectas a cualquier framework. La opción mínima es usar el propio Ollama con un loop de tool calling, que cubrimos en el post original.

Con MLX en Apple Silicon. Si tienes una Mac con chip M2/M3/M4, MLX te da el mejor rendimiento por vatio. La integración se ve así:

pip install mlx-lm
mlx_lm.generate --model meta/muse-glimmer-30b \
  --prompt "Lístame los archivos modificados hoy" \
  --max-tokens 512

Con llama.cpp en Linux. El camino del purista. Compilas con soporte CUDA:

# Clonar y compilar
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release

# Servir el modelo
./build/bin/llama-server -m muse-glimmer-30b.Q4_K_M.gguf \
  --port 8080 --ctx-size 32768 --n-gpu-layers 99

Y desde otro proceso, lo consumes por HTTP con el formato clásico de completion. La ventana de 32K tokens que soporta Glimmer es otra cosa que cambia las reglas: en local puedes tener un agente con memoria de las últimas horas de conversación sin tener que compactar a mano.

Qué benchmark mirar antes de emocionarte

Tres evaluaciones concretas que reporta el paper de Meta y que sirven para entender si Glimmer encaja en tu caso:

SWE-Bench. Resolución de issues reales de GitHub. Glimmer llega a niveles comparables con modelos de 70B de hace seis meses. Si tu caso de uso es coding agéntico, este es el número que tienes que mirar.

MCP-Atlas. Tests sobre servidores MCP (recuerda el post de MCP). Glimmer maneja bien tools externas con schemas estrictos, que es exactamente lo que vas a hacer cuando lo conectes a tu base de datos, a tu API de Jira o a lo que sea.

tau-Bench. Simulación de conversaciones con usuarios y tools. Es el benchmark más cercano a "agente de producción con clientes", y Glimmer compite con modelos el doble de grandes. Esa es la noticia importante: en workflows agénticos reales, un 30B bien entrenado le gana a un 70B generalista.

Lectura crítica: los benchmarks son útiles, pero no cuentan toda la historia. Lo que no dice el paper y conviene que pruebes tú mismo: latencia bajo carga continua, deriva de calidad cuando el contexto se acerca a los 32K tokens, y cómo se comporta el agente cuando le metes 50 tools disponibles en vez de 5. Esos son los tres números que importan en producción y que solo tu workload te puede dar.

Por qué Meta eligió este momento para abrir pesos

La columna del FT donde Zuckerberg ataca a los rivales "cerrados" no es marketing casual. Meta viene de una etapa en la que su contribución al open source de IA se frenó en seco. Llama 4, en abril de 2025, fue su último lanzamiento grande con pesos abiertos, tuvo una recepción tibia, y desde ahí la casa se concentró en modelos cerrados internos.

La movida con Glimmer es estratégica y técnica a la vez: Meta necesita diferenciarse de Anthropic, OpenAI y Google en el segmento de modelos locales, y Glimmer es la primera entrega de un plan para llenar exactamente ese hueco. Si funciona, el efecto composición con el ecosistema open (Ollama, llama.cpp, MLX, LM Studio) crea una alternativa real al stack cerrado que hoy domina.

Para los que estamos del lado del desarrollo, eso significa que los próximos seis meses van a traer un aluvión de modelos agénticos locales. Glimmer no es la última noticia, es la primera de una serie. Vale la pena empezar a experimentar ahora, entender las capacidades y los límites, y tener el setup listo para cuando llegue el siguiente.

Mi opinión después de la primera hora con los pesos

Descargué el GGUF cuantizado, lo levanté con llama.cpp y lo probé contra tres workflows reales (un agente que opera sobre archivos locales, uno que consulta la API de GitHub y uno que hace code review de un PR abierto). Las primeras observaciones:

Lo que funciona muy bien: tool calling estructurado, recuperación frente a errores de API y respuesta a instrucciones multi-step. La diferencia con modelos pequeños anteriores (Qwen 2.5 7B, Gemma 2 9B) es notable: Glimmer mantiene el plan a lo largo de 8-10 pasos sin perder el hilo. Para un agente always-on, eso es la diferencia entre algo usable y algo que te hace sufrir cada cinco minutos.

Lo que todavía está verde: la multimodalidad en el binario cuantizado no está pulida. Procesa las imágenes, pero la latencia sube notablemente cuando se mezclan con texto largo. Para casos donde la imagen es central, conviene usar el modelo full-precision y sacrificar un poco de velocidad.

Lo que falta confirmar: estabilidad bajo carga continua. Un agente que corre 8 horas seguidas provoca thermal throttling en GPUs de consumo, y ahí la latencia se degrada. Todavía no tengo datos de 24 horas, pero el fin de semana lo dejo corriendo y vuelvo con los números.

Veredicto preliminar: Glimmer no reemplaza a Claude Opus 5 ni a GPT-5.6 en razonamiento puro. Pero para el caso específico de agente local always-on, con tool calling serio, en hardware de consumo, hoy no tiene competencia directa. Si lo que quieres es un agente que corra en tu máquina sin depender de la nube, este es el primer modelo que cumple la promesa sin que tengas que hacer 10 commits de mitigación cada vez que algo falla.

Lo voy a tener corriendo en local las próximas semanas como reemplazo de varios workflows que hoy dependen de APIs externas. Si el resultado se sostiene, viene un post detallado de la arquitectura: cómo persistir memoria entre reinicios, qué monitorizar y cómo integrarlo con MCP sin que la latencia local te arruine la experiencia.

Fuentes

• Introducing Muse Glimmer — anuncio oficial de Meta
• Mark Zuckerberg attacks 'closed' AI rivals — contexto estratégico en el FT
• Muse Glimmer en Hugging Face — pesos y documentación
• Needle 2 de Cactus Compute — el caso opuesto: 14 MB para microcontroladores