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

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
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.
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.”
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.
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.
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.
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.
| Component | Value |
|---|---|
| Type | Dense causal transformer + perception encoder |
| Total parameters | ~29.6B (includes ~1.8B vision encoder) |
| Layers | 52 |
| Hidden dimension | 6,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 |
| FFN | SwiGLU, intermediate dimension 19,968 |
| Position encoding | RoPE (θ = 500,000) on local layers only |
| Vision encoder | ViT-G/14, ~1.8B parameters, 50 layers, up to 4,096 visual tokens per image |
| Vocabulary | 202,048 tokens |
| Context | 131,072 tokens |
| Knowledge cutoff | January 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.
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.
| Category | Benchmark | Muse Glimmer 30B | Gemma4-31B | Qwen3.6-27B |
|---|---|---|---|---|
| Agentic | MCP Atlas (Public) | 75.5 | 54.2 | 62.5 |
| DeepSearch QA | 74.6 | 61.7 | 71.1 | |
| τ3-Banking | 23.5 | 15.1 | 16.7 | |
| WildClawBench | 47.6 | 37.6 | 43.2 | |
| GDPVal-AA v2 | 953 | 811 | 1141 | |
| Gaia2 | 43.3 | 36.4 | 40.0 | |
| SkillsBench (with skills) | 44.3 | 32.4 | 46.6 | |
| OSWorld-Verified | 65.9 | 58.5 | 75.6 | |
| Agentic coding | SWE-Bench Pro | 51.2 | 36.9 | 50.2 |
| SWE-Bench Verified | 76.0 | 66.6 | 77.2 | |
| TerminalBench 2.1 (terminus2) | 51.7 | 43.4 | 60.7 | |
| SciCode | 43.6 | 43.4 | 39.8 | |
| Multimodal | Charxiv Reasoning | 78.8 | 77.7 | 78.4 |
| ScreenSpot Pro | 75.4 | 75.9 | 76.1 | |
| OmniDocBench v1.5 | 75.8 | 72.5 | 77.8 | |
| MMMU Pro | 74 | 73 | 75 | |
| Reasoning | IFBench | 77.0 | 76.0 | 70.8 |
| AIME 2026 | 94.7 | 89.2 | 94.1 | |
| GPQA Diamond | 83.5 | 85.7 | 84.2 | |
| HLE Text | 22.0 | 23.6 | 23.1 | |
| AA-LCR | 80.0 | 68.3 | 73.3 | |
| Beam128K | 65.1 | 58.2 | 63.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 as of 2026-11-16, per 1M tokens, from the DeepInfra model page:
| Tier | Input | Output | Cached 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.
Muse Glimmer uses DeepInfra’s OpenAI-compatible endpoint:
https://api.deepinfra.com/v1/openai/chat/completionsAuthorization: Bearer $DEEPINFRA_TOKENRequest and streaming examples are on the Muse Glimmer 30B API page.
| Parameter | Value / default | Notes |
|---|---|---|
| Reasoning strength | low, medium, high, xhigh | Model-specific. Set in the system prompt as Reasoning strength: high. Meta recommends high or xhigh for coding and agent tasks |
top_k | 64 (Meta recommended) | Not part of the OpenAI schema; pass via extra_body |
temperature | 1.0 (Meta recommended) | |
top_p | 0.95 (Meta recommended) | |
model | meta-models/Muse-Glimmer-30B | Required |
messages | array | Text and image_url content parts |
max_tokens | integer | Caps output length; see Output limits |
stream | true / false | Server-sent events, ending with [DONE] |
stop | array | Stop sequences |
presence_penalty, frequency_penalty | 0 by default | Penalize repetition |
response_format | {"type": "json_object"} | JSON mode |
tools, tool_choice | OpenAI tool schema | Function calling |
service_tier | "flex" or "priority" | Only on models that support the tier |
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)
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},
)
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.
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
tools and tool_choice with Reasoning strength: high for multi-step tool use.
Kimi K2.5 API Benchmarks: Latency, Throughput & Cost<p>About Kimi K2.5 Kimi K2.5 is Moonshot AI’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 […]</p>
Frontier-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 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’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 […]</p>
© 2026 DeepInfra. All rights reserved.