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

Muse Glimmer 30B Is Now Available on DeepInfra - Deep Infra

Published on 2026.11.16 by DeepInfra
Muse Glimmer 30B Is Now Available on DeepInfra - Deep Infra

Meta reports that Muse Glimmer 30B scores 75.5 on MCP Atlas, a multi-tool agent benchmark, which puts it 13.0 points ahead of Qwen3.6-27B and 21.3 ahead of Gemma4-31B in Meta’s own comparison. It’s a model built to run agents, and the release matters for another reason too: it’s Meta’s first open-weight model since Llama 4, and it ships under Apache 2.0 instead of the Llama community license.

Muse Glimmer comes from Meta Superintelligence Labs and was released on August 10, 2026. It’s a dense ~29.6B-parameter transformer with a 1.8B vision encoder, takes text and images as input, returns text, and has a 131,072-token context window. Meta built it for agents that run locally: tool calling with precise schemas, long multi-step plans, and recovering from failed tool calls, with a 4-bit build small enough for a 24 GB GPU. You set how hard it thinks with a single line in the system prompt.

Muse Glimmer 30B is now available on DeepInfra at $0.30 per million input tokens and $1.20 per million output tokens, through an OpenAI-compatible API with zero data retention.

Is Muse Glimmer MoE? No. It’s a dense model: all ~29.6B parameters are active on every token. That’s a change from Llama 4 Scout and Maverick, which were mixture-of-experts models.

Is Muse Glimmer open source? The weights are open. Meta publishes them on Hugging Face under Apache 2.0, a permissive license that allows commercial use, modification and redistribution, with no monthly-active-user cap. Meta also ships a separate usage policy alongside the license, and describes the training data without releasing it. So “open-weight” is the precise term.

Benchmarks

There is no earlier Muse Glimmer to compare against, and Meta’s table doesn’t include Llama 4. Meta compares it with two models of similar size, Gemma4-31B and Qwen3.6-27B. The rows below come from that table. All scores are vendor-reported, with Muse Glimmer at high reasoning strength and both peers in thinking mode.

BenchmarkMuse Glimmer 30BGemma4-31BQwen3.6-27BΔ vs best peer
MCP Atlas (Public)75.554.262.5+13.0
DeepSearch QA74.661.771.1+3.5
τ3-Banking23.515.116.7+6.8
SWE-Bench Pro51.236.950.2+1.0
SWE-Bench Verified76.066.677.2−1.2
OSWorld-Verified65.958.575.6−9.7
TerminalBench 2.1 (terminus2)51.743.460.7−9.0
AA-LCR80.068.373.3+6.7
GPQA Diamond (AA)83.585.784.2−2.2
MMMU Pro747375−1

Source: Muse Glimmer model card. Vendor-reported; Meta labels the GPQA Diamond row as an Artificial Analysis evaluation.

Across Meta’s full 22-row table, Muse Glimmer leads 12 rows. Its wins are on tool-heavy agent tasks and long context. MCP Atlas is the widest gap, and it also leads DeepSearch QA, τ3-Banking, SWE-Bench Pro and AA-LCR, a long-context reasoning test.

It loses where the agent drives a computer directly. Qwen3.6-27B beats it by 9.7 points on OSWorld-Verified (desktop control) and by 9.0 on TerminalBench 2.1 (shell work), the two widest gaps in the table. Qwen3.6-27B also edges it on SWE-Bench Verified and MMMU Pro, and Gemma4-31B leads on GPQA Diamond. If your agent spends most of its time in a terminal or a GUI, test Qwen3.6-27B too.

Meta ran every row, and it doesn’t publish the token budgets or harness settings in the model card. Treat the table as a guide to where the model is strong, not a result you’ll reproduce exactly. Meta also says Muse Glimmer is “generally less capable than Muse Spark,” its closed flagship.

What Makes This Model Different

Meta trained Muse Glimmer in three stages. First came logit distillation from Muse Spark, where the small model learns to match the large model’s output distributions. Then mid-training on longer-context, agent-heavy data. Last, post-training combined supervised fine-tuning, on-policy distillation and reinforcement learning. The goal was a model that does the boring parts of agent work reliably, not one that tops every reasoning chart.

Dense and built for local hardware

The architecture is designed to fit on a single GPU. A repeating pattern of three sliding-window (local) attention layers to one global layer, plus only two KV heads, keeps the KV cache small. Meta’s 4-bit build brings the language model under 20 GB, which leaves room for the cache, the vision encoder and a speculative-decoding drafter in a 24 GB or 32 GB budget. Meta reports 0.2% to 1.0% average accuracy loss for its two 4-bit variants. If you start on the hosted API and later need an on-device fallback, the same weights run in both places.

Controllable reasoning strength

Muse Glimmer has four reasoning levels: low, medium, high and xhigh. You set the level with a line in the system prompt (Reasoning strength: high), not with a request parameter. Meta recommends high or xhigh for coding, agentic work and complex problems, and its benchmark numbers use high. For routing, extraction and other simple steps, low or medium returns faster and spends fewer tokens.

Multimodal input for agents

A dedicated perception encoder takes interleaved text and images, up to 4,096 visual tokens per image. That makes screenshots, charts and documents usable inside an agent loop. There’s no audio input or output, and video works only as individual frames.

Things to check before your first call

  • Reasoning tokens count toward output. At high or xhigh, the model spends output tokens on thinking. OpenRouter lists a 16,384-token completion limit for the model. Set max_tokens explicitly and leave headroom on hard prompts.
  • Use Meta’s sampling settings. Meta recommends temperature 1.0, top_p 0.95 and top_k 64. top_k isn’t part of the OpenAI schema, so pass it in extra_body.
  • Context is 131,072 tokens. That covers most agent sessions, but it’s far shorter than the 10M tokens Llama 4 Scout advertised, so very large retrieval jobs belong on a long-context model.

Getting Started on DeepInfra

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

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

There is no promotional discount on Muse Glimmer, so these list prices are what you budget against. Cached input is about 87% cheaper than fresh input, which matters for agents that resend the same system prompt and tool definitions on every turn. As an example, 10M input and 2M output tokens cost $3.00 + $2.40 = $5.40. Muse Glimmer doesn’t currently offer DeepInfra’s Flex or Priority tiers, so requests run at the standard tier.

  • Model ID: meta-models/Muse-Glimmer-30B
  • Context: 131,072 tokens
  • Input: text and images. Output: text
  • Features: JSON output, function calling, zero data retention
  • API: OpenAI-compatible. Base URL https://api.deepinfra.com/v1/openai, endpoint /chat/completions, header Authorization: Bearer $DEEPINFRA_API_KEY
  • Model-specific settings: reasoning strength in the system prompt; top_k via extra_body

DeepInfra is the cheaper of the two providers OpenRouter routes Muse Glimmer to ($0.30/$1.20 vs Together’s $0.35/$1.50). Together has posted lower latency in OpenRouter’s measurements, so if time to first token is your main constraint, compare the live numbers there.

The example below runs one agent step with a tool definition.

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEEPINFRA_API_KEY"],
    base_url="https://api.deepinfra.com/v1/openai",
)

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up the shipping status of an order by ID",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

response = client.chat.completions.create(
    model="meta-models/Muse-Glimmer-30B",
    messages=[
        {"role": "system", "content": "Reasoning strength: high"},
        {"role": "user", "content": "Where is order A-1042, and when will it arrive?"},
    ],
    tools=tools,
    temperature=1.0,
    top_p=0.95,
    max_tokens=4096,
    extra_body={"top_k": 64},
)

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

To send an image, put an image_url content part in the user message next to the text. You can try the model in the browser on the demo tab, see curl, JavaScript and streaming examples on the API page, or run the open weights on a private endpoint for dedicated capacity and your own generation limits.

Conclusion

Muse Glimmer 30B is worth evaluating if you build tool-calling agents and want an Apache 2.0 model you can run both hosted and on your own hardware. Start with multi-tool workflows, search-and-answer agents and repository-level coding tasks, where Meta’s numbers show it ahead of its size class. Run Qwen3.6-27B alongside it if your agents mostly drive a terminal or a desktop, since that’s where Muse Glimmer trails. The open-weight licensing guide covers what to check before you ship any open model, including the usage policy that comes with this one.

For steps that don’t need reasoning, such as routing, classification or short extraction, Gemma 4 31B costs $0.20 in and $0.40 out on DeepInfra. For bounded yes/no choices inside an agent loop, see Decision Models: The Fast Layer for AI Agents. The Muse Glimmer model overview has the full spec sheet and parameter table, and the pricing guide works through monthly cost scenarios.

If you’re an early-stage startup, DeepStart offers about 50 billion free tokens (counted at DeepSeek V4 Flash prices) to companies founded in the last two years that have raised between $250K and $10M. Otherwise, open the model page, create an API key, and run your own agent prompts against it.

Related articles
From Precision to Quantization: A Practical Guide to Faster, Cheaper LLMsFrom Precision to Quantization: A Practical Guide to Faster, Cheaper LLMs<p>Large language models live and die by numbers—literally trillions of them. How finely we store those numbers (their precision) determines how much memory a model needs, how fast it runs, and sometimes how good its answers are. This article walks from the basics to the deep end: we’ll start with how computers even store a [&hellip;]</p>
DeepSeek V4 Pro: Model Overview, Features & Performance GuideDeepSeek V4 Pro: Model Overview, Features & Performance Guide<p>DeepSeek V4 Pro is a 1.6-trillion parameter Mixture-of-Experts (MoE) model from DeepSeek, released on April 24, 2026 under the MIT license. It is designed for advanced reasoning, complex software engineering, and long-running agentic tasks, and arrives alongside DeepSeek-V4-Flash, a lighter 284B-parameter variant built for faster, lower-cost inference. The V4 series is DeepSeek&#8217;s first two-tier lineup [&hellip;]</p>
Qwen3.5 122B A10B API Benchmarks: Latency, Throughput & CostQwen3.5 122B A10B API Benchmarks: Latency, Throughput & Cost<p>About Qwen3.5 122B A10B Qwen3.5 122B A10B is Alibaba Cloud&#8217;s mid-tier multimodal foundation model, released in February 2026. It is a multimodal vision-language Mixture-of-Experts model supporting text, image, and video inputs, designed for native multimodal agent applications. It features 122 billion total parameters with 10 billion activated per token through a hybrid architecture that integrates [&hellip;]</p>