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

| Provider | Best For |
|---|---|
| DeepInfra | Lowest price per token and per task, BF16 weights, zero data retention |
| Together AI | Fastest time to first token and first answer, long single responses |
| Fireworks AI | LoRA fine-tuning and dedicated on-demand GPUs |
| OpenRouter | One API key across providers, with automatic failover |
| Hugging Face Inference Providers | Calling the model from the Hugging Face SDKs you already use |
| Featherless AI | Flat-rate interactive chat on a monthly plan |
| Vultr | A private inference endpoint on your own cloud GPUs |
| Ollama / LM Studio | Running the 4-bit build on a laptop or workstation |
| vLLM / SGLang | Self-hosting the full BF16 model on your own servers |
Quick reference by priority
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.
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.
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)
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.
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.
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.
Fireworks is the best pick when you want to fine-tune Muse Glimmer on your own data and serve the result on dedicated GPUs.
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.
OpenRouter is the best pick when you want one API key and automatic failover between the providers that serve Muse Glimmer.
meta/muse-glimmer-30breasoning_effort, tools, response_format and structured outputs through OpenRouter’s APIOpenRouter 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.
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.
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.
Featherless AI is the best pick when you want to chat with Muse Glimmer interactively at a fixed monthly cost.
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.
Vultr is the best pick when you want a private Muse Glimmer endpoint on GPUs in your own cloud account.
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.
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 is the quickest way to run the 4-bit model on a Mac or a PC with one large GPU.
ollama run muse-glimmer (Ollama library)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 inputMeta 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 is the best pick for a desktop app with a GUI and a local OpenAI-compatible server.
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 are the right choice when you want to serve the full BF16 model to many users on your own servers.
vllm serve "meta-models/Muse-Glimmer-30B" exposes an OpenAI-compatible serverpython3 -m sglang.launch_server --model-path "meta-models/Muse-Glimmer-30B"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.
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.
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.
DeepSeek 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 […]</p>
Getting 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 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 […]</p>
© 2026 DeepInfra. All rights reserved.