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

Best Muse Glimmer 30B API Providers and Platforms in 2026 - Deep Infra

Published on 2026.11.16 by DeepInfra
Best Muse Glimmer 30B API Providers and Platforms in 2026 - Deep Infra

Summary of the Best Muse Glimmer 30B Providers

ProviderBest For
DeepInfraLowest price per token and per task, BF16 weights, zero data retention
Together AIFastest time to first token and first answer, long single responses
Fireworks AILoRA fine-tuning and dedicated on-demand GPUs
OpenRouterOne API key across providers, with automatic failover
Hugging Face Inference ProvidersCalling the model from the Hugging Face SDKs you already use
Featherless AIFlat-rate interactive chat on a monthly plan
VultrA private inference endpoint on your own cloud GPUs
Ollama / LM StudioRunning the 4-bit build on a laptop or workstation
vLLM / SGLangSelf-hosting the full BF16 model on your own servers

Quick reference by priority

  • Cheapest hosted API: DeepInfra ($0.30 in / $1.20 out / $0.04 cached per 1M tokens)
  • Lowest latency: Together AI (1.40 s to first token, 18.5 s to first answer token on Artificial Analysis)
  • Custom fine-tune: Fireworks AI
  • No cloud at all: Ollama or LM Studio

Muse Glimmer is Meta’s 30B open-weight agent model, released August 10, 2026 under Apache 2.0. It is a dense model, not a mixture-of-experts, so all of its roughly 29.6B parameters are active on every token. It takes text and images as input and has a 131,072-token context window. Meta designed it for local agents: a 4-bit build fits in a 24 GB or 32 GB memory envelope, and the release ships a DFlash speculative-decoding drafter. This means “where to run it” has two answers: a hosted API when you need throughput, uptime and no hardware to manage, or your own machine when you want offline, private, fixed-cost inference.

For hosted APIs, the serving questions are cost per token, cost per finished task, output speed, and how long you wait before the answer starts. Muse Glimmer reasons before it answers, so time to first token (TTFT) and time to first answer token are very different numbers: the first counts any streamed reasoning tokens, and the second includes the model’s whole thinking phase. For an agent loop, the second is the one you feel. Speed, latency and cost-per-task figures below come from Artificial Analysis (Muse Glimmer at High reasoning, 5-day averages, pulled 2026-11-16) and OpenRouter. Prices and features come from each provider’s own pages. Pricing as of 2026-11-16.

Hosted API Providers

1. DeepInfra

DeepInfra is the best pick when cost per token and cost per agent task matter most, and you still want full-precision weights and a production API.

  • Blended price: $0.21 per 1M tokens, the lowest of the tracked providers (Artificial Analysis, 7:2:1 cache-hit/input/output blend)
  • Current rates: $0.30 input / $1.20 output / $0.04 cached input per 1M tokens. There is no promotional discount on this model; this is the list price.
  • Cost per task: $0.13 per Artificial Analysis Intelligence Index task, versus $0.23 on Together AI (about 42% less)
  • Context: 131,072 tokens; max output 16,384 tokens per request on OpenRouter’s endpoint listing
  • Precision: BF16, per OpenRouter’s endpoint listing
  • Measured speed: 86 tokens/s output, 1.93 s to first token, 28.8 s to first answer token, 5.1 minutes per Intelligence Index task (Artificial Analysis). At the 100k-token input workload it holds 91.7 tokens/s.
  • Prompt caching: 100% cache hit rate in Artificial Analysis’s multi-turn agentic sessions (median of the four weeks to October 26, 2026)
  • Features: OpenAI-compatible API, JSON output, function calling, image input, zero data retention
  • Deployment: serverless per-token API, or a private endpoint on dedicated GPUs billed by the minute

The low cost per task comes from the low list price combined with a high cache hit rate. Agent loops resend the same long prefix on every turn, and cached input on DeepInfra costs $0.04 per million tokens instead of $0.30. The limitations: DeepInfra is not the fastest provider to first token. Artificial Analysis measures Together AI about 10 seconds sooner to the first answer token, and OpenRouter’s one-week median latency is also lower on Together (0.50 s vs 0.71 s). DeepInfra also caps a single completion at 16,384 tokens, while Together allows much longer responses. If your agent mostly makes short tool calls over long, repeated context, DeepInfra is the cheapest hosted option. If a user is waiting on every reply, test both.

A first call with the OpenAI SDK, with reasoning strength set in the system prompt as Meta’s model card describes:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEEPINFRA_API_KEY"],
    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": "Plan the tool calls needed to triage a failing CI job."},
    ],
    temperature=1.0,
    top_p=0.95,
    extra_body={"top_k": 64},
)
print(response.choices[0].message.content)
copy

The endpoint is /chat/completions and the auth header is Authorization: Bearer $DEEPINFRA_API_KEY. Full parameters are on the Muse Glimmer 30B API page.

2. Together AI

Together AI is the best pick when the time until the answer starts is your main constraint, or when you need single responses longer than 16K tokens.

  • Blended price: $0.25 per 1M tokens (Artificial Analysis, 7:2:1 blend)
  • Current rates: $0.35 input / $1.50 output / $0.04 cached input per 1M tokens
  • Cost per task: $0.23 per Intelligence Index task
  • Context: 131,072 tokens; max output 117,964 tokens per request on OpenRouter’s endpoint listing
  • Precision: FP8, per Together’s model list
  • Measured speed: 89 tokens/s output, 1.40 s to first token, 18.5 s to first answer token, 4.9 minutes per Intelligence Index task, 0% endpoint error rate (Artificial Analysis). At the 100k-token workload, output drops to 78.8 tokens/s.
  • Prompt caching: 87.0% cache hit rate in Artificial Analysis’s agentic sessions
  • Features: function calling, structured outputs; a Meta launch partner

Together is faster than DeepInfra on Artificial Analysis’s latency measurements: about half a second sooner to the first token and about 10 seconds sooner to the first answer token, with slightly higher average output speed. Artificial Analysis names it the best-performing provider by time per task. The cost is a higher price: input is 17% more and output 25% more than DeepInfra, and the gap per agent task is wider (about 1.7x) because more of the input misses the cache. Together also serves FP8 weights where DeepInfra serves BF16. For interactive chat on top of the model, Together’s latency lead is real. For high-volume background agents, it costs more per task.

3. Fireworks AI

Fireworks is the best pick when you want to fine-tune Muse Glimmer on your own data and serve the result on dedicated GPUs.

  • Fine-tuning: LoRA fine-tuning of Muse Glimmer 30B, deployed as your own model
  • Deployment: on-demand dedicated GPUs, “high reliability and no rate limits”
  • Serverless: being deprecated for this model starting September 25, 2026. Fireworks tells serverless users to migrate to a different model; on-demand stays available.
  • Compliance: SOC 2 Type 2, ISO 27001, ISO 27701, ISO 42001
  • Context: 131K+ tokens, text and image input, reasoning strength low through xhigh

Meta names Fireworks as a hosted launch partner, but as of this writing it is not a per-token option for Muse Glimmer: you pay for dedicated GPU time. That makes sense when you need a custom LoRA or guaranteed capacity with no shared rate limits, and not when you want to pay per call. Fireworks is not on OpenRouter’s provider list and is not tracked by Artificial Analysis for this model, so there are no comparable speed figures.

4. OpenRouter

OpenRouter is the best pick when you want one API key and automatic failover between the providers that serve Muse Glimmer.

  • Providers routed: DeepInfra and Together, at each provider’s own price (OpenRouter)
  • Model slug: meta/muse-glimmer-30b
  • Measured speed (1-week P50): DeepInfra 90 tokens/s at 0.71 s latency; Together 64 tokens/s at 0.50 s
  • Availability: 99.93% over three days; OpenRouter reports 99.95% with routing versus 99.52% without, because it retries on the other provider when one errors
  • Effective input price after caching: $0.0721/M on DeepInfra, $0.0800/M on Together
  • Routing modes: Balanced (price + speed), Nitro (fastest), Floor (cheapest)
  • Supported parameters: both endpoints accept reasoning_effort, tools, response_format and structured outputs through OpenRouter’s API

OpenRouter adds no compute of its own here, so its speed and price are those of the provider it picks. Its value is resilience and a single bill across many models. The trade-off is one more hop in the request path, and less direct control over which provider and precision serve each call unless you pin a provider.

5. Hugging Face Inference Providers

Hugging Face Inference Providers is the best pick when your code already uses the Hugging Face client libraries and you want to call Muse Glimmer without a separate provider account.

  • Live providers for this model: DeepInfra, Featherless AI and Together, all marked “live” in Hugging Face’s provider mapping for the model
  • Task: conversational (chat completions)
  • Billing: through your Hugging Face account, routed to the underlying provider

This is a convenience layer: the request runs on one of the three providers above, so speed and limits follow that provider. It suits prototyping and teams that live in the Hugging Face ecosystem. For production traffic at volume, going direct gives you the provider’s full feature set and support.

6. Featherless AI

Featherless AI is the best pick when you want to chat with Muse Glimmer interactively at a fixed monthly cost.

  • Model page: meta-models/Muse-Glimmer-30B
  • Plans: Chat at $25/month with unlimited tokens, 32K context and 4 concurrent units, for human-typed interactive use only; Developer from $50/month, billed per token, with up to 256K context and 100 concurrent units; custom Business contracts on dedicated GPUs
  • Data: prompts and completions are never stored
  • API: OpenAI-compatible endpoint

The Chat plan’s 32K context window is a quarter of the model’s 131K, and its terms exclude API traffic, background automation and coding agents. That rules it out for the agent workloads Muse Glimmer was built for. The Developer plan lifts those limits but bills per token.

7. Vultr

Vultr is the best pick when you want a private Muse Glimmer endpoint on GPUs in your own cloud account.

  • Deployment: “Deploy Private Inference Endpoint” for Muse Glimmer 30B, with hardware and inference-engine choices
  • Reference benchmarks: measured by Vultr on NVIDIA HGX B200 with vLLM; the detailed figures are behind an email gate
  • License and specs: reproduced from Meta’s model card (Apache 2.0, 131K+ context)

This is infrastructure, not a per-token API: you pay for the GPUs whether or not they are busy. It fits teams that need the model inside their own network boundary and already run on Vultr.

Running It Yourself

Meta built Muse Glimmer to run on a single consumer GPU, so self-hosting is a real alternative to an API. Meta lists LM Studio, vLLM with Inferact, and SGLang with RadixArk as launch partners in its Muse Glimmer docs, next to Fireworks, Hugging Face and Together. Those docs point to your own hardware and these runtimes rather than a Meta-hosted endpoint.

Ollama

Ollama is the quickest way to run the 4-bit model on a Mac or a PC with one large GPU.

  • Install and run: ollama run muse-glimmer (Ollama library)
  • Builds: muse-glimmer:30b at 18 GB; muse-glimmer:30b-mlx at 19 GB on Ollama’s MLX engine for Apple Silicon, with DFlash speculative decoding and image input
  • Context: 128K per tag; text and image input

Meta measured its own 17 GB quantized build with the DFlash drafter at 37.8 tokens/s on an M4 Max and 233.4 tokens/s on an RTX 5090 (batch size 1, greedy decoding, vendor-reported). That is fast enough for one person’s agent, not for serving a team.

LM Studio

LM Studio is the best pick for a desktop app with a GUI and a local OpenAI-compatible server.

  • Model page: meta/muse-glimmer, GGUF format, 25.77 GB download
  • Memory: at least 26 GB of RAM for the smallest build
  • Reasoning control: a “Reasoning Strength” selector in the chat template (default: high)
  • Capabilities: tool use, vision input, reasoning

Note that LM Studio’s smallest build is larger than Ollama’s 18 GB tag, so check your memory before choosing between the two.

vLLM and SGLang

vLLM and SGLang are the right choice when you want to serve the full BF16 model to many users on your own servers.

  • Weights: BF16 safetensors on Hugging Face, about 59.6 GB in total; Meta targets 64 GB of VRAM for BF16
  • vLLM: vllm serve "meta-models/Muse-Glimmer-30B" exposes an OpenAI-compatible server
  • SGLang: python3 -m sglang.launch_server --model-path "meta-models/Muse-Glimmer-30B"
  • Quantized community builds: Red Hat AI and Unsloth publish their own Muse Glimmer repositories on Hugging Face

Muse Glimmer’s architecture is new, so make sure your vLLM or SGLang release includes support for it before planning a deployment. Self-hosting has the lowest marginal cost per token once GPUs are busy, but you own scaling, uptime and upgrades. At low or spiky volume, a per-token API usually costs less than an idle 80 GB GPU.

Final Thoughts

  • Lowest cost per token and per agent task: DeepInfra, at $0.30 / $1.20 / $0.04 and $0.13 per Artificial Analysis task
  • Lowest latency to the first answer: Together AI, about 10 seconds sooner than DeepInfra on Artificial Analysis, at a higher price
  • Responses longer than 16K tokens: Together AI
  • Custom LoRA fine-tune on dedicated GPUs: Fireworks AI
  • One key, automatic failover: OpenRouter
  • Offline or on-device: Ollama or LM Studio
  • Full control at scale: vLLM or SGLang on your own GPUs

Speed rankings for this model move quickly. Artificial Analysis and OpenRouter disagree on throughput this week, and providers tune serving stacks for weeks after a launch, as covered in why open models get faster after launch. Re-check the live numbers before committing.

The Best Overall Solution

For most teams running Muse Glimmer as an API, DeepInfra is the default choice. It has the lowest list price of any hosted provider, the lowest blended price and cost per task on Artificial Analysis, BF16 weights, a 100% measured cache hit rate on agent sessions, and zero data retention, all on an OpenAI-compatible endpoint you can switch to by changing a base URL. If simpler steps in your pipeline don’t need Muse Glimmer, Gemma 4 31B and Qwen3.6-35B-A3B run on the same API at lower prices.

For more detail, see the Muse Glimmer 30B pricing guide for cost scenarios, the API provider benchmarks for speed and latency, and the model overview for architecture and parameters. Startups can apply for free credits through DeepStart; see how DeepInfra supports early-stage teams through the NVIDIA Inception program.

Related articles
DeepSeek V3.2 API Benchmarks: Latency, Throughput & CostDeepSeek V3.2 API Benchmarks: Latency, Throughput & Cost<p>About DeepSeek V3.2 DeepSeek V3.2 is a state-of-the-art large language model that unifies conversational speed and deep reasoning in a single 685B parameter Mixture of Experts (MoE) architecture with 37B parameters activated per token. It is built around three key technical breakthroughs: DeepSeek V3.2 achieved gold-medal performance in the 2025 International Mathematical Olympiad (IMO) and [&hellip;]</p>
Getting StartedGetting StartedGetting an API Key To use DeepInfra's services, you'll need an API key. You can get one by signing up on our platform. Sign up or log in to your DeepInfra account at deepinfra.com Navigate to the Dashboard and select API Keys Create a new ...
Pricing 101: Token Math & Cost-Per-Completion ExplainedPricing 101: Token Math & Cost-Per-Completion Explained<p>LLM pricing can feel opaque until you translate it into a few simple numbers: input tokens, output tokens, and price per million. Every request you send—system prompt, chat history, RAG context, tool-call JSON—counts as input; everything the model writes back counts as output. Once you know those two counts, the cost of a completion is [&hellip;]</p>