DeepInfra raises $107M Series B to scale the inference cloud — read the announcement

Muse Glimmer 30B: Model Overview & Integration Guide - Deep Infra

Published on 2026.11.16 by DeepInfra
Muse Glimmer 30B: Model Overview & Integration Guide - Deep Infra

Muse Glimmer is a 30-billion-parameter open-weight model from Meta Superintelligence Labs, released on August 10, 2026 under Apache 2.0 and built for agent workloads: tool calling, multi-step tasks, coding agents and LLM-as-a-judge evaluation. It takes text and images as input, returns text, and has a 131,072-token context window. Meta distilled it from Muse Spark, its proprietary flagship, and sized it so a 4-bit build runs on a single 24 GB consumer GPU.

It is a dense model, not a mixture-of-experts: all of its roughly 29.6B parameters, including a 1.8B vision encoder, are active on every token. There is no earlier Muse Glimmer, so this guide compares it with Meta’s last open-weight family, Llama 4, and with the two ~30B models Meta benchmarks it against, Gemma4-31B and Qwen3.6-27B.

Muse Glimmer 30B is available on DeepInfra through an OpenAI-compatible API with zero data retention, JSON output and function calling. If you need something cheaper for simple steps, Gemma 4 31B and Qwen3.6-35B-A3B are on the same API. The model string is:

meta-models/Muse-Glimmer-30B

What changed from Llama 4

Muse Glimmer is not a new Llama version. Meta’s comparison table does not include Llama 4, so the differences below are about design and licensing, not head-to-head scores.

License

Llama 4 shipped under Meta’s own community license, which caps monthly active users before a separate commercial license is needed. Muse Glimmer uses plain Apache 2.0 with no user cap, and Meta lists it as intended for commercial and research use. Meta still ships a separate usage policy next to the license, so read both before you put it in a product. Third-party coverage describes Muse Glimmer as Meta’s first open-weight model since Llama 4; Meta itself calls it “the next model from Meta Superintelligence Labs.”

Architecture: dense instead of MoE

Llama 4 Scout and Maverick were Meta’s first mixture-of-experts models: 17B active parameters each, with 109B and 400B total. Muse Glimmer goes the other way, a dense ~29.6B model small enough to quantize below 20 GB. The trade-off is context: Llama 4 Scout advertised 10M tokens, and Muse Glimmer supports 131,072.

Training method

Meta trained Muse Glimmer in three phases: logit distillation from Muse Spark’s outputs, mid-training on longer-context, agent-heavy data with richer reasoning traces, then post-training that combines supervised fine-tuning, on-policy distillation and reinforcement learning across general, reasoning, coding and agentic domains (Meta). Meta’s stated targets are reliable tool calls with precise schemas, long-horizon plans, and failure recovery: when a tool call fails, the model is trained to diagnose and retry instead of stopping.

Controllable reasoning strength

Muse Glimmer has four reasoning levels: low, medium, high and xhigh. You set the level in the system prompt, and Meta recommends high or xhigh for coding, agentic tasks and complex problems. Meta’s published benchmark numbers use high.

A note on speed figures

Meta’s speed claims are for local hardware. With the 17 GB quantized build and the bundled DFlash speculative-decoding drafter, Meta reports 233.4 tok/s on an RTX 5090 (3.1x over 74.9 tok/s without the drafter) and 37.8 tok/s on an Apple M4 Max (1.5x), measured at batch size 1 with greedy decoding. Those numbers do not describe hosted API throughput. On Artificial Analysis’s provider benchmarks, sustained output speed is close (86 tok/s on DeepInfra, 89 on Together AI), but Together reaches the first token sooner (1.40 s vs 1.93 s) and the first answer token sooner (18.5 s vs 28.8 s, thinking time included). DeepInfra is cheaper per task ($0.13 vs $0.23 per Intelligence Index task). If time to first answer matters more than cost, Together is the faster route today.

Technical Architecture

ComponentValue
TypeDense causal transformer + perception encoder
Total parameters~29.6B (includes ~1.8B vision encoder)
Layers52
Hidden dimension6,656
Attention[Local, Local, Local, Global] repeating; 2,048-token sliding window; gated attention
Heads (Q / KV)32 / 2 (GQA 16:1), head dimension 128
FFNSwiGLU, intermediate dimension 19,968
Position encodingRoPE (θ = 500,000) on local layers only
Vision encoderViT-G/14, ~1.8B parameters, 50 layers, up to 4,096 visual tokens per image
Vocabulary202,048 tokens
Context131,072 tokens
Knowledge cutoffJanuary 4, 2026

Source: Muse Glimmer model card.

The 3:1 local-to-global attention pattern and the two KV heads keep the KV cache small. That is what lets Meta fit the 4-bit weights, the KV cache, the vision encoder and the drafter in a 24 GB or 32 GB memory budget. The DFlash drafter is a 5-layer block-diffusion model that proposes 16 tokens per forward pass, which the main model then verifies in parallel.

Video is not a native input: frames are processed as individual images. There is no audio in or out.

Benchmarks

All scores below are vendor-reported from Meta’s model card. Muse Glimmer ran at high reasoning strength; Gemma4-31B and Qwen3.6-27B ran in thinking mode. Meta labels the GPQA Diamond and HLE rows as Artificial Analysis evaluations. Meta did not include Llama 4 or any closed model.

CategoryBenchmarkMuse Glimmer 30BGemma4-31BQwen3.6-27B
AgenticMCP Atlas (Public)75.554.262.5
DeepSearch QA74.661.771.1
τ3-Banking23.515.116.7
WildClawBench47.637.643.2
GDPVal-AA v29538111141
Gaia243.336.440.0
SkillsBench (with skills)44.332.446.6
OSWorld-Verified65.958.575.6
Agentic codingSWE-Bench Pro51.236.950.2
SWE-Bench Verified76.066.677.2
TerminalBench 2.1 (terminus2)51.743.460.7
SciCode43.643.439.8
MultimodalCharxiv Reasoning78.877.778.4
ScreenSpot Pro75.475.976.1
OmniDocBench v1.575.872.577.8
MMMU Pro747375
ReasoningIFBench77.076.070.8
AIME 202694.789.294.1
GPQA Diamond83.585.784.2
HLE Text22.023.623.1
AA-LCR80.068.373.3
Beam128K65.158.263.0

Source: Muse Glimmer model card. Vendor-reported.

Muse Glimmer leads 12 of these 22 rows. Its biggest lead is on MCP Atlas, a multi-tool benchmark, where it scores 21.3 points above Gemma4-31B and 13.0 above Qwen3.6-27B. It also leads on the long-context rows (AA-LCR, Beam128K) and on SWE-Bench Pro. Its narrowest lead is SciCode, 0.2 points over Gemma4-31B.

Qwen3.6-27B leads 8 rows, and the losses cluster in computer use and terminal work: OSWorld-Verified (65.9 vs 75.6) and TerminalBench 2.1 (51.7 vs 60.7) are Muse Glimmer’s two widest gaps. Qwen3.6-27B also edges it on SWE-Bench Verified and on three of the four multimodal rows. Gemma4-31B leads on GPQA Diamond and HLE. If your agent spends most of its time driving a desktop or a shell, test Qwen3.6-27B as well.

On safety rows, Muse Glimmer has the highest utility on Siren AgentDojo (94.2) but a higher prompt-injection attack success rate than Gemma4-31B (28.4 vs 25.6). Meta also says Muse Glimmer is “generally less capable than Muse Spark”, so tasks that need frontier-level reasoning still belong on a larger model.

Pricing

Pricing as of 2026-11-16, per 1M tokens, from the DeepInfra model page:

TierInputOutputCached input
Standard (list)$0.30$1.20$0.04

There is no promotional discount on this model, so the standard price is the list price to budget against. A workload with 10M input and 2M output tokens costs $3.00 + $2.40 = $5.40 at standard rates.

Muse Glimmer doesn’t carry DeepInfra’s Flex (0.8×) or Priority (1.5×) tags yet, so every request runs at the standard tier. A "service_tier": "flex" request sent to it is served and billed at standard. If you need a discounted batch path today, models with the Flex tag such as Gemma 4 31B offer one; see how Flex works. Eligible startups can apply for free credits through DeepStart.

Getting started

Muse Glimmer uses DeepInfra’s OpenAI-compatible endpoint:

  • Base URL: https://api.deepinfra.com/v1/openai
  • Endpoint: /chat/completions
  • Auth header: Authorization: Bearer $DEEPINFRA_TOKEN

Request and streaming examples are on the Muse Glimmer 30B API page.

Parameters

ParameterValue / defaultNotes
Reasoning strengthlow, medium, high, xhighModel-specific. Set in the system prompt as Reasoning strength: high. Meta recommends high or xhigh for coding and agent tasks
top_k64 (Meta recommended)Not part of the OpenAI schema; pass via extra_body
temperature1.0 (Meta recommended)
top_p0.95 (Meta recommended)
modelmeta-models/Muse-Glimmer-30BRequired
messagesarrayText and image_url content parts
max_tokensintegerCaps output length; see Output limits
streamtrue / falseServer-sent events, ending with [DONE]
stoparrayStop sequences
presence_penalty, frequency_penalty0 by defaultPenalize repetition
response_format{"type": "json_object"}JSON mode
tools, tool_choiceOpenAI tool schemaFunction calling
service_tier"flex" or "priority"Only on models that support the tier

Python

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_DEEPINFRA_TOKEN",
    base_url="https://api.deepinfra.com/v1/openai",
)

response = client.chat.completions.create(
    model="meta-models/Muse-Glimmer-30B",
    messages=[
        {"role": "system", "content": "Reasoning strength: high"},
        {"role": "user", "content": "Write a Python function that retries an HTTP call with exponential backoff."},
    ],
    temperature=1.0,
    top_p=0.95,
    max_tokens=4096,
    extra_body={"top_k": 64},
)

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

To send an image, such as a screenshot for a UI agent, use a content array:

response = client.chat.completions.create(
    model="meta-models/Muse-Glimmer-30B",
    messages=[
        {"role": "system", "content": "Reasoning strength: medium"},
        {"role": "user", "content": [
            {"type": "text", "text": "Which button submits this form?"},
            {"type": "image_url", "image_url": {"url": "https://example.com/screenshot.png"}},
        ]},
    ],
    extra_body={"top_k": 64},
)
copy

Output limits

The context window is 131,072 tokens, shared between your prompt and the response. OpenRouter lists a completion limit of 16,384 tokens for the model. At high or xhigh, reasoning tokens count against that limit, so long answers to hard problems can stop early. Lower the reasoning strength for routine steps, or continue a cut-off answer in a follow-up request that includes the partial response.

Meta does not publish the token budgets behind its benchmark runs in the model card, so expect some difference between your results and the vendor table, especially on long agentic tasks. To reproduce long-run evals, run the open weights on a DeepInfra private endpoint, where you control the generation limits.

Conclusion

Muse Glimmer is Meta’s open-weight agent model for the 30B class: dense, Apache 2.0, multimodal input, and tuned for tool calling and long multi-step tasks. Meta’s own numbers put it ahead of Gemma4-31B and Qwen3.6-27B on most agentic and long-context rows, behind Qwen3.6-27B on computer use and terminal work, and below Meta’s closed Muse Spark overall. The context window is far shorter than Llama 4 Scout’s, so it is not the pick for multi-million-token retrieval.

On DeepInfra it costs $0.30 in and $1.20 out per million tokens, with $0.04 cached input, which makes it a cheap option for agent loops that resend the same system prompt and tool definitions on every turn. Our launch post covers the first call, the pricing guide works through monthly cost scenarios, and the API benchmarks article compares providers on speed and latency.

Next Steps

  • Optimize costs: read how Flex works and use it for batch and evaluation jobs on models that carry the Flex tag.
  • Build agents: use tools and tool_choice with Reasoning strength: high for multi-step tool use.
  • Deploy privately: run Muse Glimmer on a dedicated endpoint for predictable throughput and your own output limits. For why open-model speeds often improve after launch, see Why Open Models Get Faster Weeks After Launch.
Related articles
Kimi K2.5 API Benchmarks: Latency, Throughput & CostKimi K2.5 API Benchmarks: Latency, Throughput & Cost<p>About Kimi K2.5 Kimi K2.5 is Moonshot AI&#8217;s flagship open-source reasoning model, released in January 2026. It is a native multimodal agentic model built through continual pretraining on approximately 15 trillion mixed visual and text tokens. The model features a Mixture-of-Experts (MoE) architecture with 1 trillion total parameters and 32 billion activated parameters. Kimi K2.5 [&hellip;]</p>
Frontier-Level Agents on Open Models: LangChain Deep Agents + NVIDIA Nemotron 3 Ultra, Live on DeepInfraFrontier-Level Agents on Open Models: LangChain Deep Agents + NVIDIA Nemotron 3 Ultra, Live on DeepInfraOpen models have reached frontier-level agent performance. Starting today, you can point LangChain Deep Agents at NVIDIA Nemotron 3 Ultra running on DeepInfra and get top-tier agent accuracy at roughly 10x lower cost than leading closed models.
Best SaaS Platforms for Deploying Gemma 4 in 2026Best SaaS Platforms for Deploying Gemma 4 in 2026<p>Gemma 4 is available across a range of platforms — from fully managed API providers to local runners and no-code builders. The right choice depends on what you&#8217;re optimizing for: cost, latency, data privacy, local execution, or zero infrastructure overhead. This guide breaks down the top options by use case so you can match the [&hellip;]</p>