Quick answer: Meta Muse Glimmer is a 30-billion-parameter dense multimodal model released under Apache 2.0 on August 10, 2026, distilled from Muse Spark and built for autonomous agents running on consumer hardware. It scores 35 on the Artificial Analysis Intelligence Index, ranking 5th of 140 open-weight models in its size class against a class median of 9. On Qubrid AI it costs $0.25 per 1M input tokens and $1.05 per 1M output tokens, callable through an OpenAI-compatible endpoint.

What Muse Glimmer is, and why Meta built it this way

On August 10, 2026, Meta released a model designed around a premise most labs had stopped arguing for: that the interesting frontier is not a bigger model in a bigger datacenter, but a capable one running on hardware you already own.

Muse Glimmer is a 30-billion-parameter dense causal language model with a dedicated perception encoder, distilled from Muse Spark and purpose-built for autonomous agentic tasks on consumer hardware. As Meta's research team writes, it integrates multi-step reasoning, reliable tool use, multimodal understanding and failure recovery into a single model that runs locally without cloud infrastructure or network access.

Everything ships under Apache 2.0: full-precision BF16 weights, two 4-bit quantized variants, the DFlash speculative-decoding drafter, and the frozen perception encoder.

The launch drew unusually broad coverage for a mid-sized model. Bloomberg framed it as fuel for the debate over whether powerful AI should be freely downloadable or kept under tighter control. Engadget noted that Mark Zuckerberg's accompanying essay argued for distributing capability widely rather than centralising it. CNBC reported that Meta also committed to opening the weights for Muse Spark 1.2.

Adoption followed. The model card shows over 609,000 downloads in its first month, 160 community quantizations, 38 fine-tunes, 12 adapters and 18 Spaces built on it.

Specifications at a glance

Architecture, and what each design choice buys you

Meta made several unusual choices here, and each one traces back to the same constraint: this had to fit and run on a machine under a desk.

Dense, deliberately

Muse Glimmer activates every parameter for every token. No routing, no expert selection, no variance across token pathways.

That is a choice, not an oversight. As NVIDIA's technical blog explains, most large language models are optimised for chat, prioritising single-turn interaction and fast time-to-first-token, while agentic workloads demand something else: an agent scaffolding a software project or managing a knowledge base may execute many sequential tool calls in one session, and needs reliability, consistency, long-context coherence and sustained throughput rather than a fast first token.

A dense model gives predictable per-token cost and no routing variance across a long agent run. For a model whose entire purpose is long-horizon execution, that predictability is worth more than the compute savings a mixture-of-experts design would deliver.

Three local layers for every global one

The attention pattern repeats [Local, Local, Local, Global] with a 2,048-token sliding window, and RoPE is applied only on the local layers.

Three quarters of the 52 layers only attend within a 2,048-token window. Only every fourth layer sees the full sequence. This is what makes a 131,072-token context window affordable on a dense 30B model rather than a memory problem, and it pairs with an aggressive 16:1 grouped-query attention ratio (32 query heads to 2 KV heads) that shrinks the KV cache further.

A real vision encoder, frozen and shipped

The perception encoder is a ~1.8B parameter ViT-G/14 with 50 layers and patch size 14, accepting up to 4,096 visual tokens per image. It is documented in its own paper and released as a separate artifact.

For an agent, this is not a nice-to-have. Screenshots, charts, dashboards, error dialogs and scanned documents are how an agent perceives the systems it operates. Note the boundary though: video is processed as individual frames rather than as video, and audio is not supported at all.

DFlash: predicting 16 tokens at a time

The most interesting engineering in the release is the speculative decoding drafter, based on the DFlash block-diffusion paper.

Standard speculative decoding drafts tokens one at a time. DFlash predicts an entire block of 16 tokens in a single forward pass, and the main model verifies the whole block in parallel, accepting what is correct and correcting what is not. Output quality is identical; throughput is not.

Meta's measured speedups:

Read the footnote on that table, because it matters more than the headline. Those measurements were taken at batch size 1 with greedy decoding. They describe one person talking to one model. They are not throughput numbers for a service handling concurrent users, and the distinction comes up again below.

Official benchmarks against Gemma4-31B and Qwen3.6-27B

Meta compares Muse Glimmer directly against the two obvious alternatives in its size class. Reproduced in full, including the rows where Glimmer loses.

Agentic

Agentic coding

Multimodal

General reasoning

Reading the pattern honestly

Muse Glimmer wins 12 of these 22 rows and loses 10. The wins are not randomly distributed, and neither are the losses.

It leads decisively on agentic orchestration. MCP Atlas at 75.5 against 62.5 for the nearest competitor is a 13-point margin. τ³-Banking, WildClawBench, DeepSearch QA and Gaia2 all show the same shape. These benchmarks measure whether a model can run a multi-step workflow through tools without falling over, which is exactly what Meta optimised for.

It also leads on long-context reasoning and instruction following. AA-LCR at 80.0 against 68.3 and 73.3 is a wide margin, and Beam128K repeats it. For a model that ships a 131K window, that is the right place to be strong.

It trails on raw capability measures. Qwen3.6-27B beats it on OSWorld-Verified by nearly 10 points, on TerminalBench 2.1 by 9, on GDPVal-AA v2 by a wide margin, and edges it on SWE-Bench Verified, SkillsBench, OmniDocBench, ScreenSpot Pro and MMMU Pro. Gemma4-31B takes GPQA Diamond and HLE Text.

The honest summary: Muse Glimmer is the better agent and not the better model. If your workload is a scaffold executing tool calls over a long horizon, its wins are in exactly the right column. If you need the strongest raw scores on scientific reasoning or computer use in its size class, they are elsewhere. Note also that these are Meta's own evaluations of Meta's own model against competitors it selected.

Independent benchmarks from Artificial Analysis

Artificial Analysis evaluated Muse Glimmer at high reasoning strength and its numbers give a useful outside check.

Intelligence Index v4.1.1 is a nine-evaluation composite: GDPval-AA v2, τ³-Banking, Terminal-Bench v2.1, SciCode, Humanity's Last Exam, GPQA Diamond, CritPt, AA-Omniscience and AA-LCR.

Three things stand out.

35 against a class median of 9 is a large gap, and it places Muse Glimmer fifth among 140 open-weight models in the 4B-to-40B band. Read the comparison class carefully though: this is a ranking within small open-weight models, not against frontier systems. Larger models score substantially higher.

The latency figure is the quiet standout. A 0.79-second time to first token against a class median of 2.04 seconds is roughly 2.6x better than typical. For an agent making dozens of sequential tool calls in one session, per-call latency compounds in a way that per-token throughput does not. This is the metric that matches Meta's design intent most directly, and it is the one that gets the least attention.

It is concise. 48M output tokens across the index, exactly at the median, which Artificial Analysis rates as fairly concise. That matters commercially, because reasoning tokens bill as output. A model that reasons efficiently costs less to run than its per-token price suggests.

Reasoning strength, and the setting people get wrong

Muse Glimmer supports four reasoning levels: low, medium, high, xhigh. Meta recommends high or xhigh for complex problem solving, coding and agentic tasks.

Here is the part that will cost you a debugging session if you skip it.

Reasoning strength is not an API parameter. It is a line in your system prompt.

Reasoning strength: high

If you are migrating from a model family that uses a reasoning_effort parameter or a chat_template_kwargs block, passing one to Muse Glimmer does nothing. There is no error. The request succeeds and the model runs at whatever its default behaviour is, and you conclude the setting has no effect.

The correct approach:

messages = [
    {"role": "system", "content": "Reasoning strength: high"},
    {"role": "user", "content": "..."},
]

What to set:

Because the setting lives in the system prompt, it also sits at the very front of your context, which has a useful side effect: it is part of the stable prefix that earns implicit cache hits. Keep it there and keep everything variable after it.

Muse Glimmer pricing on Qubrid AI

Pay-as-you-go, no minimum commitment, no reserved capacity requirement.

At a standard 7:2:1 cache-hit, input, output ratio, that is a blended rate of roughly $0.176 per 1M tokens.

For context, Artificial Analysis tracks a median of $0.325 input and $1.35 output across providers serving this model, for a blended $0.23. The Qubrid rate sits meaningfully below that on every line.

The cache discount is unusually steep

Cached input at $0.03 against $0.25 uncached is an 88% discount, one of the larger implicit-cache discounts on any model.

That matters disproportionately here because of what Muse Glimmer is for. Agent loops re-send a large, stable prefix on every turn: system prompt with the reasoning strength directive, tool schemas, accumulated conversation. All of it identical call after call.

Worked example. An agent runs a 12-turn session with a 40,000-token system prompt and tool schema that never changes:

• Without cache hits: 12 × 40,000 × $0.25 / 1,000,000 = $0.120

• With cache hits after turn one: (40,000 × $0.25 + 440,000 × $0.03) / 1,000,000 = $0.023

An 81% reduction on the static portion of input spend.

To earn it, order your prompt by stability: reasoning strength directive, system instructions, tool schemas, few-shot examples, persistent documents, then conversation, then the current message. A single variable token near the front, a timestamp or session ID, invalidates everything after it.

Monthly cost estimates

Assuming no cache hits, so treat these as ceilings:

Calling the Muse Glimmer API on Qubrid AI

The endpoint is OpenAI-compatible. An existing OpenAI SDK integration needs three changes: base URL, API key, model string.

Basic completion

from openai import OpenAI

# Initialize the OpenAI client with Qubrid base URL
client = OpenAI(
    base_url="https://platform.qubrid.com/v1",
    api_key="QUBRID_API_KEY",
)

response = client.chat.completions.create(
    # Must match the exact model ID from the docs - variations will cause errors.
    model="meta-models/Muse-Glimmer-30B",
    messages=[
        {
            "role": "user",
            "content": "Explain the main benefits of using a chat completion API for text generation."
        }
    ],
    max_tokens=4096,
    temperature=1,
    top_p=1,
    stream=False
)

print(response.choices[0].message.content)

The model string is meta-models/Muse-Glimmer-30B exactly as written. Case and the organisation prefix both matter.

Adding reasoning strength

The call above runs at the model's default behaviour. To control reasoning depth, add a system message:

response = client.chat.completions.create(
    model="meta-models/Muse-Glimmer-30B",
    messages=[
        {"role": "system", "content": "Reasoning strength: high"},
        {"role": "user", "content": "..."},
    ],
    max_tokens=4096,
    temperature=1,
    top_p=1,
)

Recommended sampling parameters

Meta publishes a single recommended configuration rather than per-benchmark settings:

The Qubrid quickstart uses top_p=1, a fine general-purpose starting point. Meta's published values are worth A/B testing against it when you tune for a specific workload. top_k is not a standard OpenAI parameter, so pass it through extra_body:

response = client.chat.completions.create(
    model="meta-models/Muse-Glimmer-30B",
    messages=messages,
    temperature=1.0,
    top_p=0.95,
    max_tokens=4096,
    extra_body={"top_k": 64},
)

Vision input

messages = [
    {"role": "system", "content": "Reasoning strength: high"},
    {
        "role": "user",
        "content": [
            {
                "type": "image_url",
                "image_url": {"url": "https://your-domain.com/dashboard-screenshot.png"}
            },
            {
                "type": "text",
                "text": "Which metric is trending down, and by how much?"
            }
        ]
    }
]

response = client.chat.completions.create(
    model="meta-models/Muse-Glimmer-30B",
    messages=messages,
    max_tokens=2048,
)

The model accepts interleaved text and images, up to 4,096 visual tokens per image. Video is not supported as video; if you need it, sample frames and pass them as images.

Tool calling

Tool use is the model's strongest capability, so this is the code path that matters most:

tools = [{
    "type": "function",
    "function": {
        "name": "search_documents",
        "description": "Search the internal document store",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {"type": "string"},
                "limit": {"type": "integer", "default": 10},
            },
            "required": ["query"],
        },
    },
}]

response = client.chat.completions.create(
    model="meta-models/Muse-Glimmer-30B",
    messages=[
        {"role": "system", "content": "Reasoning strength: high"},
        {"role": "user", "content": "Find our Q3 retention analysis and summarise the top three findings."},
    ],
    tools=tools,
    tool_choice="auto",
    temperature=1.0,
    top_p=0.95,
    max_tokens=4096,
)

Meta specifically trained for failure recovery: when a tool call fails or returns an unexpected result, the model is designed to diagnose the error and retry rather than halt. Build your tool responses to return useful error messages rather than bare failures, because the model can act on them.

Streaming

stream = client.chat.completions.create(
    model="meta-models/Muse-Glimmer-30B",
    messages=messages,
    stream=True,
    stream_options={"include_usage": True},
)

for chunk in stream:
    if not chunk.choices:
        if chunk.usage:
            print("Usage:", chunk.usage)
        continue
    delta = chunk.choices[0].delta
    if getattr(delta, "content", None):
        print(delta.content, end="", flush=True)

The honest case for hosted access to a laptop model

Muse Glimmer was built to run on your machine. So why call it over an API?

This deserves a straight answer rather than a pitch, because for a genuine single-user local agent, running it locally is the right call and the weights are Apache 2.0.

Here is when hosted access is actually the better engineering decision.

Concurrency changes the arithmetic completely. Meta's 233 tokens per second on an RTX 5090 was measured at batch size 1 with greedy decoding. That is one request at a time. A local card serving ten simultaneous agent sessions does not deliver ten times that; it degrades sharply. Server-side batching is what makes concurrent throughput work, and it is not something a single consumer GPU does well.

Local means 4-bit. Hosted can mean full precision. Meta published the degradation table, and it is worth taking seriously:

Degradation is small and Meta validated it carefully. But 64GB of VRAM is not a laptop, so running locally means accepting the quantized build. An API call does not.

You cannot ship 20GB to every environment. CI pipelines, serverless functions, container fleets, mobile backends, ephemeral test runners. A 20GB model download per environment is not a deployment strategy. An API key is.

Fleet consistency. Ten engineers running local builds means ten slightly different setups: different quantization, different runtime, different drafter configuration. Debugging a behaviour difference across that is miserable. One endpoint means one answer.

Evaluation before commitment. Testing whether Muse Glimmer suits your workload should not require every evaluator to download 20GB and configure llama.cpp first.

The honest counter-case: if you are building a genuinely local agent, one where the entire point is that data never leaves the device, run it locally. That is what Meta built it for and it works. Qubrid also offers on-demand GPU compute and on-premises appliances if you want dedicated infrastructure without giving up managed serving.

Hardware requirements and quantization quality

If you do self-host, these are the real numbers.

Meta compressed the language model to approximately 4-bit precision, shrinking it to under 20 GB, which leaves headroom for the KV cache, the perception encoder and the DFlash drafter to run simultaneously inside a 24GB or 32GB envelope.

Degradation was measured as an average across accuracy metrics on 15 common benchmarks.

Per NVIDIA, the model fits within the VRAM of a single GPU with no sharding, CPU offloading or external endpoints, across GeForce RTX 5090, DGX Spark, DGX Station and Jetson platforms. Optimised integrations exist for llama.cpp, MLX and ExecuTorch, and hardware partners across AMD, Arm, Dell, Intel and NVIDIA have tuned their stacks for it.

Everything is Apache 2.0, including the drafter and the vision encoder, so fine-tuning and redistribution carry no licensing friction.

Where Muse Glimmer fits, and where it does not

Strong fits

Long-horizon tool-calling agents. The MCP Atlas, τ³-Banking, WildClawBench and Gaia2 wins all point here, and this is what Meta optimised for. Combined with a 0.79-second time to first token, it suits agents making many sequential calls.

Latency-sensitive interactive work. Time to first token roughly 2.6x better than the class median is the specification that shows up most directly in how an application feels.

Screenshot and document understanding inside agent loops. A real 1.8B vision encoder means the agent can read the interface it is operating.

Long-context reasoning. AA-LCR at 80.0 against 68.3 and 73.3 for its comparison set is a wide margin over a 131K window.

Multilingual work. Trained on more than 100 languages, though Meta notes not all have been evaluated.

Synthetic data generation and LLM-as-judge, both listed as intended uses, where the price and the throughput matter more than topping a leaderboard.

Weaker fits

Computer-use automation. OSWorld-Verified at 65.9 trails Qwen3.6-27B at 75.6 by nearly 10 points. If clicking through GUIs is the core workload, benchmark alternatives.

Terminal-heavy coding agents. TerminalBench 2.1 at 51.7 against 60.7 is a real gap.

Knowledge-heavy question answering. HLE Text at 22.0 and GPQA Diamond at 83.5 both trail the comparison set, and AA-Omniscience, which measures knowledge reliability and hallucination, is one of the nine evaluations in the Intelligence Index. Meta's own limitations section states plainly that the model may produce inaccurate responses. Keep human review on factual output.

Audio or video. Audio is explicitly out of scope. Video is processed as individual frames, not as video.

Anything reaching under-18 users. Meta's model card states the model is not intended to be downloaded or used by individuals under 18, and places responsibility on deployers where systems may reach them.

Safety and agentic deployment

Meta assessed Muse Glimmer under its Advanced AI Scaling Framework. The model does not meet the framework's definition of Frontier AI, since it is broadly less capable than Muse Spark, but the preparedness team evaluated it anyway and assigned Moderate or lower risk across chemical and biological, cyber, and loss-of-control categories. The cyber and loss-of-control designations are inferred from Muse Spark 1.0's ratings rather than directly measured, and Meta says so.

Train-time mitigations include safety supervised fine-tuning covering tool-use boundaries and prompt-injection resistance, safety reinforcement learning, and synthetic training data encoding data minimisation and local-first execution.

Two things worth carrying into your own deployment.

Meta's own recommendation is not to deploy the model as an endpoint in itself. It should sit inside a system with guardrails appropriate to the context, with human-in-the-loop confirmation for irreversible actions.

Local execution does not solve agentic security. Keeping data on-device reduces cloud exposure, but it does nothing about prompt injection, excessive permissions, or an agent taking an unintended action. Those are properties of your scaffold, not of where the weights sit. Meta's own benchmark table reports Muse Glimmer at a 28.4% attack success rate on Siren AgentDojo, better than Qwen3.6-27B at 40.3 and worse than Gemma4-31B at 25.6, alongside the highest utility score of the three at 94.2. Resistant, not immune.

Troubleshooting

Reasoning strength appears to do nothing. It is a system prompt line, not a parameter. Use {"role": "system", "content": "Reasoning strength: high"}. Passing reasoning_effort or chat_template_kwargs silently does nothing.

Model not found. The string is meta-models/Muse-Glimmer-30B, with the organisation prefix and exact casing.

top_k rejected by the SDK. It is not a standard OpenAI parameter. Pass it through extra_body={"top_k": 64}.

Outputs feel unfocused or repetitive. Check your sampling parameters against Meta's recommendation of temperature 1.0, top_p 0.95, top_k 64. Framework defaults tuned for other models frequently underperform here.

Video input rejected or misread. Video is not supported as a modality. Sample frames and send them as images.

Cache hit rate near zero. Something variable is sitting near the front of your prompt, ahead of the reasoning strength line and system instructions. Move timestamps and session IDs to the end.

Agent halts on a tool error instead of recovering. The model is trained to diagnose and retry, but only if it can see what went wrong. Return descriptive error messages from your tools rather than bare failure codes.

Frequently asked questions

What is Meta Muse Glimmer? A 30-billion-parameter dense multimodal model released by Meta Superintelligence Lab in August 2026 under Apache 2.0, distilled from Muse Spark and built for autonomous agents on consumer hardware.

How much does the Muse Glimmer API cost? On Qubrid AI, $0.25 per 1M input tokens and $1.05 per 1M output tokens, with implicit cached input at $0.03 per 1M tokens. That is a blended rate of roughly $0.176 per 1M tokens.

What is Muse Glimmer's Intelligence Index score? 35 on the Artificial Analysis Intelligence Index at high reasoning strength, ranking 5th of 140 open-weight models in its size class against a class median of 9.

Is Muse Glimmer open source? Yes, under Apache 2.0. That covers the BF16 weights, both 4-bit quantized variants, the DFlash drafter and the perception encoder, and it permits commercial use, modification and redistribution.

What is Muse Glimmer's context length? 131,072 tokens or more, enabled by a [Local, Local, Local, Global] attention pattern with a 2,048-token sliding window on the local layers.

How do I set reasoning strength on Muse Glimmer? Through the system prompt, as the line Reasoning strength: high. The four levels are low, medium, high and xhigh. It is not an API parameter.

Does Muse Glimmer support vision? Yes, through a dedicated ~1.8B parameter ViT-G/14 perception encoder, accepting up to 4,096 visual tokens per image. Video is processed as individual frames and audio is not supported.

What hardware do I need to run Muse Glimmer locally? About 24GB of VRAM for the K-Quant-17GB build at 1.0% degradation, 32GB for K-Quant-Dynamic at 0.2%, or 64GB for full precision. It fits a single GPU with no sharding.

How fast is Muse Glimmer? Artificial Analysis measured 108.9 tokens per second and a 0.79-second time to first token, against class medians of 100.9 and 2.04 respectively. Locally with DFlash speculative decoding, Meta measured 233.4 tokens per second on an RTX 5090 at batch size 1.

What is DFlash? A block-diffusion speculative decoding drafter that predicts 16 tokens in a single forward pass, which the main model then verifies in parallel. It delivered a 3.1x speedup on an RTX 5090 in Meta's testing, with identical output quality.

Muse Glimmer vs Qwen3.6-27B: which is better? Muse Glimmer leads on agentic orchestration benchmarks including MCP Atlas, DeepSearch QA, τ³-Banking, WildClawBench and Gaia2, plus long-context reasoning and instruction following. Qwen3.6-27B leads on OSWorld-Verified, TerminalBench 2.1, GDPVal-AA v2, SWE-Bench Verified and several multimodal measures. Pick by workload rather than by overall winner.

Can I fine-tune Muse Glimmer? Yes. Apache 2.0 permits it, PyTorch TorchTitan supports training on your own data, and 38 fine-tunes plus 12 adapters already exist publicly.

Why use the API if it runs on a laptop? Concurrency, full-precision serving instead of a 4-bit local build, deployment into environments that cannot host a 20GB model, consistent behaviour across a team, and evaluation without local setup. For genuinely single-user on-device agents, running locally remains the right choice.

What is Muse Glimmer's knowledge cutoff? January 4, 2026.

Is Muse Glimmer safe for autonomous agents? Meta rates it Moderate or lower risk across chem/bio, cyber and loss-of-control, with the latter two inferred rather than directly measured. Meta recommends deploying it inside a system with guardrails and human confirmation for irreversible actions rather than as a bare endpoint.

Get started

meta-models/Muse-Glimmer-30B is live now on the Qubrid AI platform at $0.25 per 1M input tokens.

1. Create an account and generate an API key at platform.qubrid.com

2. Point your existing OpenAI SDK at https://platform.qubrid.com/v1

3. Set model="meta-models/Muse-Glimmer-30B"

4. Put Reasoning strength: high in your system prompt

Qubrid AI serves 60+ open-source models behind a single OpenAI-compatible API, alongside on-demand GPU compute and on-premises AI appliances for teams that need to own the hardware.