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

Two hosted APIs serve Muse Glimmer 30B today, and Artificial Analysis benchmarks both. Meta publishes the weights but runs no hosted endpoint for this model, so the third row is the self-hosting baseline.
| Provider | Blended price (1M, 7:2:1) | Output speed (t/s) | Latency (TTFT) | Time to first answer token | Cost per Intelligence Index task | Best use case |
|---|---|---|---|---|---|---|
| DeepInfra | $0.21 | 86 | 1.93 s | 28.79 s | $0.13 | Cost-sensitive agents, batch and high-volume pipelines |
| Together AI | $0.25 | 89 | 1.40 s | 18.54 s | $0.23 | Interactive, latency-sensitive chat and agents |
| Meta (first-party) | No hosted API | Self-hosted | Self-hosted | Self-hosted | Your hardware cost | Local and offline agents on your own GPU |
Data: Artificial Analysis, pulled 2026-11-16, for “Muse Glimmer (High)” (reasoning strength set to High). Pricing as of 2026-11-16.
How to read these numbers. Artificial Analysis runs its standard workloads with a 10K-token input by default and averages each endpoint’s runs over the past five days, re-testing every six hours. Blended price weights cache-hit, input and output tokens 7:2:1, which reflects an agentic session where most of the prompt is served from cache. Output speed is end-to-end: output tokens divided by total request time, including time to first token. Muse Glimmer reasons before it answers, so time to first answer token, which includes the thinking phase, matters more than raw TTFT for anything user-facing. All figures move over time. DeepInfra has no promo on this model, so the blended figure above reflects its full list price.
Muse Glimmer is Meta’s agent-focused 30B model, distilled from its proprietary Muse Spark and built to run on a single consumer GPU. Meta’s own benchmark table, which is vendor-reported, has it ahead of Gemma4-31B and Qwen3.6-27B on agentic tests such as MCP Atlas (75.5) and SWE-Bench Pro (51.2). The independent Artificial Analysis index gives a more modest picture: 6.3 against a class median of 8, with weak results on its hardest agentic coding evals (0.5% on Terminal-Bench 4.0). Where it does stand out is token economy. It reaches its score with roughly half the output tokens of a typical model in its class, which keeps per-task cost and wall-clock time down even though its per-token price is high for a 30B model.
Two API details matter when you pick a provider. The model is dense, so every token runs through all ~29.6B parameters, and its per-token price is well above sparse MoE alternatives such as Qwen3.6-35B-A3B ($0.10 input / $0.95 output on DeepInfra). Completions are capped at 16,384 tokens on both hosted routes. Reasoning depth is set in the system prompt (Reasoning strength: low | medium | high | xhigh), not by a dedicated API parameter, and every number in this article was measured at High.
DeepInfra gets the recommendation on price. It has the lowest blended price of the two providers ($0.21 vs $0.25 per 1M, 16% lower) and the lowest list price on every token type that differs: $0.30 vs $0.35 input and $1.20 vs $1.50 output. Cached input is $0.04 on both. The gap widens on Artificial Analysis’s cost-per-task measure, which accounts for how many tokens the model actually spends: $0.13 per Intelligence Index task on DeepInfra against $0.23 on Together AI, 43% lower.
Speed is close. DeepInfra’s output speed is 86 tok/s against Together AI’s 89, a gap of about 3%. Latency is where DeepInfra trails: 1.93 s to first token versus 1.40 s, and 28.79 s versus 18.54 s to the first answer token after reasoning. If a person is watching a spinner, that 10-second difference is noticeable. In a background agent loop or a batch job it matters much less than the per-token bill.
To see what the price gap means at volume, take 1B tokens a month in the 7:2:1 mix Artificial Analysis uses: 700M cached, 200M input, 100M output. On DeepInfra that is 700M × $0.04 + 200M × $0.30 + 100M × $1.20 = $28 + $60 + $120 = $208. The same mix on Together AI costs $28 + $70 + $150 = $248.
The Muse Glimmer 30B model page lists zero data retention, JSON output, function calling and image input, and the endpoint is OpenAI-compatible (https://api.deepinfra.com/v1/openai, header Authorization: Bearer $DEEPINFRA_API_KEY). Full parameters are on the API page. To cut DeepInfra’s time to first answer on interactive calls, lower the reasoning strength:
from openai import OpenAI
import os
client = OpenAI(
api_key=os.environ["DEEPINFRA_API_KEY"],
base_url="https://api.deepinfra.com/v1/openai",
)
resp = client.chat.completions.create(
model="meta-models/Muse-Glimmer-30B",
messages=[
{"role": "system", "content": "Reasoning strength: medium"},
{"role": "user", "content": "Summarize the failing test output and propose a fix."},
],
temperature=1.0,
top_p=0.95,
max_tokens=4096,
extra_body={"top_k": 64},
)
print(resp.choices[0].message.content)
Speeds on newly launched open models often improve in the weeks after release as serving stacks are tuned; we cover why in Why Open Models Get Faster After Launch. Re-check the latency gap before you lock in a provider on speed alone.
Together AI leads on every speed and latency metric Artificial Analysis tracks for this model. Its output speed of 89 tok/s is narrowly ahead, but its time to first answer token is 18.54 s, about 10 seconds faster than DeepInfra. It also completes an Intelligence Index task slightly faster (4.9 vs 5.1 minutes) and had a 0.0% endpoint error rate over the measurement window, against 0.9% for DeepInfra. Meta named Together AI as a launch partner, and it has the slightly higher cache discount of the two (89% vs 87%).
The trade-off is cost. Together AI’s output price is 25% higher ($1.50 vs $1.20), its blended price is $0.25, and its cost per index task is $0.23, roughly 1.8× DeepInfra’s. For a chat product or an IDE assistant where users wait on the first answer, that premium may be worth paying. For agents that run unattended, it mostly buys seconds no one is waiting on.
Meta doesn’t offer Muse Glimmer through its own paid API. Its developer site lists Muse Glimmer as “built to enable always-on, local agents, available on Hugging Face,” and the Muse Glimmer docs tell developers to run it on their own hardware. Meta’s Model API serves its other Muse models. So for this model, the first-party baseline is the open weights themselves.
That is a deliberate design choice. The full-precision model needs over 55 GB of memory, but Meta’s 4-bit builds bring the language model under 20 GB, enough for a 24 GB or 32 GB GPU with the KV cache, vision encoder and DFlash speculative-decoding drafter loaded alongside. Meta reports 233.4 tok/s on an RTX 5090 at batch size 1 with the K-Quant-17GB build and DFlash (Hugging Face card). That figure is vendor-reported and measured differently from the hosted numbers above, so don’t compare it directly. Self-hosting suits offline or private-data agents. You pay for the hardware and the ops, and a single consumer GPU won’t sustain the concurrency of a hosted endpoint.
The provider field for Muse Glimmer 30B is small, and the choice comes down to one trade-off:
Before you choose, consider the model as well as the host. Muse Glimmer is concise but sits below its size-class median on the Artificial Analysis index, and it is priced above most open models of its size. Run your own prompt mix at the reasoning strength you plan to ship with. The overview covers the model itself (Muse Glimmer 30B model overview), and the Muse Glimmer 30B pricing guide has workload cost scenarios.
To get started, call Muse Glimmer 30B on DeepInfra, or deploy it on a private endpoint for dedicated GPU capacity. Startups can apply for free credits through DeepStart; see how the program works with NVIDIA in Supporting the Next Wave of AI Startups with the NVIDIA Inception Program.
GLM-5.1 on DeepInfra: Z.AI’s Agentic Engineering Model<p>Z.AI’s GLM-5.1 scores 58.4 on SWE-Bench Pro — ahead of both Claude Opus 4.6 (57.3) and GPT-5.4 (57.7) on real-world software engineering tasks. It’s the direct successor to GLM-5, designed for agentic engineering: long-horizon coding tasks, terminal operations, and repository-level work. The core design premise is that previous models, including GLM-5, tend to plateau after […]</p>
GLM-5.3-Flash Pricing, Providers & Cost<p>GLM-5.3-Flash is a model from Z.ai in the GLM-5 family, released on August 26, 2026. It’s a natively multimodal model accepting text and image input (some listings, including OpenRouter, also note video), with text output. Both Artificial Analysis and DeepInfra describe it as a 320B-parameter mixture-of-experts model with 18B active parameters per inference; DeepInfra’s listing […]</p>
Kimi K3 Pricing, Providers & Real-World Costs<p>Kimi K3 matters because it pushes an unusual combination into the same decision: open weights, a 1 million token context window, and frontier-class benchmark numbers, but at pricing still high enough to force real provider shopping. Released by Moonshot AI on July 16, 2026, it is a 2.8 trillion parameter Mixture-of-Experts model with 104 billion […]</p>
© 2026 DeepInfra. All rights reserved.