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

| Best for | Provider recommendation | Why |
|---|---|---|
| Lowest per-token price | DeepInfra | $0.30 input / $1.20 output / $0.04 cached per 1M tokens, the lowest listed rate on every token type. Artificial Analysis puts its blended price at $0.21 vs $0.25 for Together |
| Fastest first answer token | Together AI | Time to first answer token of 18.5 s vs 28.8 s on DeepInfra in Artificial Analysis tests, and lower latency on OpenRouter |
| One bill, automatic failover | OpenRouter | Routes between DeepInfra and Together at their own token prices; “Floor” mode picks the cheapest, “Nitro” the fastest |
| RAG and cache-heavy agents | DeepInfra | Cached input is $0.04 at both hosts, but DeepInfra is cheaper on the uncached input and output that remain |
| Outputs over 16K tokens in one call | Together AI | OpenRouter lists a 117,964-token completion cap for Together vs 16,384 for DeepInfra |
| Offline, private or single-user agents | Self-host the 4-bit build | Apache 2.0 weights, a 4-bit build under 20 GB and a speculative-decoding drafter make one 32 GB consumer GPU a real option |
Pricing as of 2026-11-16. DeepInfra lists no promo on this model, so the DeepInfra rates in this guide are list prices.
The short version: DeepInfra is the cheapest hosted route for Muse Glimmer 30B, Together is the faster one, and for a single developer running agents all day, a local RTX 5090 can come close to paying for itself. The scenarios below show where each of those lines falls.
Muse Glimmer 30B is Meta Superintelligence Labs’ dense, open-weight agent model, released on August 10, 2026 under Apache 2.0. All ~29.6B parameters are active on every token (it is not a mixture-of-experts), it accepts text and images, returns text, and has a 131,072-token context window. Meta distilled it from Muse Spark and built it to run locally, which makes it unusual among the models we price: the realistic alternative to an API isn’t only another API, it’s the GPU under your desk.
On Artificial Analysis, Muse Glimmer (High) scores 6 on Intelligence Index v5.0.1, below the median of 8 for comparable open-weight models. It is also one of the most concise models AA tracks: it used 39.5M output tokens to run the index, against a median of 77.7M. Low verbosity matters as much as the rate card, because output tokens are the expensive ones. AA also lists it as “expensive” against its size class on raw input and output rates. So the question this guide answers is whether its price profile fits your workload, not whether it’s the cheapest 30B model on the market. (It isn’t. More on alternatives below.)
| Token type | What it is | Why it matters for Muse Glimmer |
|---|---|---|
| Input (uncached) | Prompt tokens the provider hasn’t seen recently: new user text, retrieved documents, tool results | $0.30/M on DeepInfra. In agent loops this is often the biggest line item after caching |
| Cached input | Prompt prefix already in the provider’s cache: system prompt, tool schemas, conversation history | $0.04/M on DeepInfra, about 87% off the uncached rate. Agent loops resend history every turn, so cache hit rate drives the bill |
| Output | Generated tokens, including reasoning | $1.20/M on DeepInfra, 4× the input rate. Higher reasoning strength produces more of them |
| Image input | Images pass through Meta’s perception encoder and become visual tokens | Meta caps an image at 4,096 visual tokens. Billed as input at $0.30/M, a maximum-size image costs about $0.0012 |
| Max completion | The ceiling on output tokens per request | 16,384 on DeepInfra per OpenRouter’s listing; long generations need to be split across calls |
| Context window | Prompt plus output, per request | 131,072 tokens. Long-context RAG has to fit inside it; there’s no 1M-token mode |
What this means in practice:
The provider field is small. Artificial Analysis and OpenRouter both track two serverless hosts, DeepInfra and Together. Meta’s launch post also names Fireworks AI, but Fireworks retired serverless access to Muse Glimmer on September 25, 2026 and now offers it only on dedicated on-demand GPUs. Meta’s launch post names hosting partners and lists no first-party Meta API for this model, so there’s no lab price to benchmark against.
| Provider / route | Input /1M | Output /1M | Cached /1M | Advantage | Disadvantage | Best fit |
|---|---|---|---|---|---|---|
| DeepInfra (Standard) | $0.30 | $1.20 | $0.04 | Lowest listed rate on all three token types; zero data retention; JSON and function calling; served at BF16 per OpenRouter | Slower to first answer token than Together; 16,384-token completion cap; no Flex tier on this model yet | Cost-sensitive production, RAG, extraction |
| Together AI | $0.35 | $1.50 | $0.04 | Fastest time to first answer token; 117,964-token completion cap | 17% higher input and 25% higher output price | Interactive chat and streaming UIs, very long single outputs |
| OpenRouter, standard routing | Same as the provider it routes to | Same | Same | One API key, automatic failover, “Floor” (cheapest) or “Nitro” (fastest) routing | OpenRouter’s own platform fees and terms apply on top | Teams already on OpenRouter, or wanting failover between both hosts |
OpenRouter :batch variant (served by DeepInfra) | $0.24 | $0.96 | $0.032 | Lowest per-token rate listed anywhere for this model | Only via OpenRouter; batch behavior is set by OpenRouter, not DeepInfra’s direct API | Offline jobs already routed through OpenRouter |
| Fireworks on-demand | n/a (per GPU-hour) | n/a | n/a | Dedicated capacity, fine-tuning on the same platform | No serverless option; H100 at $8.00/hour | Teams fine-tuning on Fireworks |
| DeepInfra dedicated GPU | n/a (per GPU-hour) | n/a | n/a | Your own endpoint; A100 80GB at $1.49/hour, H100 at $2.90/hour | You pay for idle time and size it yourself | Steady, high, predictable volume |
| Self-hosted (RTX 5090, 4-bit) | $0 marginal | $0 marginal | $0 marginal | Offline, data never leaves the machine; Meta reports 233.4 tok/s with the DFlash drafter | Hardware and power cost; batch-size-1 speed; 4-bit build loses about 1% on Meta’s average | Single-developer local agents, air-gapped work |
Takeaways by workload:
Cost trap to avoid: a broken cache. In Scenario 1 below, dropping the cache hit rate from 85% to 50% raises the DeepInfra bill from $206.00 to $388.00 a month with no change in traffic. Timestamps or per-request IDs at the top of the system prompt, or reordered tool definitions, can do that quietly.
If you call Muse Glimmer through OpenRouter, you pay the routed provider’s token price plus OpenRouter’s fees. Its default “Balanced” mode weighs price and speed, “Floor” sends traffic to the cheapest host (DeepInfra at current prices), and “Nitro” to the fastest. You can also pin or exclude providers per request. OpenRouter’s one-day token share for this model is currently 89.8% Together and 10.2% DeepInfra, which suggests most routed traffic is optimizing for latency rather than price. If cost is your priority, set the routing mode explicitly instead of relying on the default.
Muse Glimmer was built for this. Meta’s 4-bit K-Quant-17GB build shrinks the language model below 20 GB and fits with its KV cache, vision encoder and DFlash drafter in a 24 GB or 32 GB card. Meta measures 74.9 tok/s on an RTX 5090 without speculative decoding and 233.4 tok/s with the DFlash drafter (batch size 1, greedy decoding, llama.cpp). Meta reports 1.0% average accuracy loss for that build across 15 benchmarks, or 0.2% for the larger K-Quant-Dynamic build. The full BF16 weights need over 55 GB, so a data-center GPU like an 80 GB A100 runs them unquantized.
To compare an owned or rented GPU with per-token pricing, you need a token mix. We use Artificial Analysis’s 7:2:1 blend (cached input : uncached input : output), which gives DeepInfra a blended price of $0.208 per 1M tokens (0.7 × $0.04 + 0.2 × $0.30 + 0.1 × $1.20). Break-even volume is the monthly fixed cost divided by that rate.
Inputs (estimates, not quotes):
| Option | Monthly fixed cost | Break-even volume (7:2:1 mix) | Throughput needed to reach it |
|---|---|---|---|
| RTX 5090, active 6 h/day | $83.29 + $18.80 power = $102.09 | ~491M tokens/month | ~757 mixed tok/s (~76 output tok/s) during the 6 active hours |
| RTX 5090, active 24/7 | $83.29 + $76.23 power = $159.52 | ~767M tokens/month | ~292 mixed tok/s (~29 output tok/s) around the clock |
| DeepInfra dedicated A100 80GB | 730 × $1.49 = $1,087.70 | ~5.23B tokens/month | ~1,990 mixed tok/s (~199 output tok/s) around the clock |
| DeepInfra dedicated H100 | 730 × $2.90 = $2,117.00 | ~10.18B tokens/month | ~3,873 mixed tok/s (~387 output tok/s) around the clock |
| Fireworks on-demand H100 | 730 × $8.00 = $5,840.00 | ~28.08B tokens/month | ~10,684 mixed tok/s (~1,068 output tok/s) around the clock |
How to read it:
| Model / listing | Best use case | Context | Input /1M | Output /1M |
|---|---|---|---|---|
| Muse Glimmer 30B | Agents, tool calling, coding agents, screenshot and document understanding | 131,072 | $0.30 ($0.04 cached) | $1.20 |
| Gemma 4 31B | Cheaper multimodal general tasks; Flex-eligible ($0.16 / $0.32) | 262,144 | $0.20 | $0.40 |
| Qwen3.6-35B-A3B | Cheap high-volume steps, long context; Flex-eligible | 262,144 | $0.10 ($0.10 cached) | $0.95 |
Muse Glimmer on DeepInfra runs behind an OpenAI-compatible endpoint (https://api.deepinfra.com/v1/openai/chat/completions, model ID meta-models/Muse-Glimmer-30B), with zero data retention, JSON output, function calling and image input. Billing is per token with no minimums. The /api page has curl, Python and JavaScript examples.
Flex isn’t available on this model yet. DeepInfra’s Flex tier charges 0.8× the standard price for requests that can wait up to 10 minutes for capacity. It’s live on models that carry the Flex tag, including Gemma 4 31B and Qwen3.6-35B-A3B above, but the Muse Glimmer page doesn’t show it, and a Flex request sent to an untagged model is served and billed at the standard tier. Budget every Muse Glimmer workload at the standard rates in this guide.
When you outgrow per-token billing, the same account rents dedicated A100, H100, H200, B200 and B300 GPUs by the minute, from $1.49/hour for an A100 80GB, so moving to a private deployment doesn’t mean changing vendors.
Why this matters: there’s no lab list price to discount from here, so the useful comparison is against the other host. DeepInfra is 14% cheaper on uncached input and 20% cheaper on output than Together, and matches it on cached input. Across the five scenarios below, that works out to 11% to 16% lower monthly bills. What you give up is roughly 10 seconds of time to first answer token at High reasoning strength, plus the 16,384-token output cap.
All five scenarios use DeepInfra standard pricing ($0.30 / $1.20 / $0.04) and compare against Together ($0.35 / $1.50 / $0.04). Token volumes are monthly. “M” means million.
| Volume | Model | Provider | Input tokens | Output tokens | Monthly cost |
|---|---|---|---|---|---|
| 25 developers, agent sessions daily | Muse Glimmer 30B (High) | DeepInfra | 2,000M (1,700M cached, 300M uncached) | 40M | $206.00 |
Coding agents resend the repo map, tool schemas and conversation history every turn, so input dwarfs output and most of it should hit the cache. This scenario assumes an 85% cache hit rate and output at 2% of input, in line with what AA measured on its agentic index. Muse Glimmer’s vendor-reported 51.2 on SWE-Bench Pro and its retry-on-failure training make it a reasonable fit for this loop.
Why DeepInfra fits: cached input is billed at $0.04, and the remaining uncached input and output are the cheapest listed.
Cost breakdown – Uncached input: 300M × $0.30/M = $90.00 – Cached input: 1,700M × $0.04/M = $68.00 – Output: 40M × $1.20/M = $48.00 – Total: $206.00/month
Same workload on Together: $105.00 + $68.00 + $60.00 = $233.00, or $27.00 more.
| Volume | Model | Provider | Input tokens | Output tokens | Monthly cost |
|---|---|---|---|---|---|
| 200,000 queries | Muse Glimmer 30B (Medium) | DeepInfra | 8,000M (6,000M cached, 2,000M uncached) | 120M | $984.00 |
Each query sends a 40,000-token prompt: a 30,000-token cached prefix (instructions plus core product docs) and 10,000 tokens of freshly retrieved passages, then returns a 600-token answer. That stays well inside the 131,072-token window, leaving room for multi-turn follow-ups.
Why DeepInfra fits: with 75% of input cached, the uncached retrieval tokens decide the bill, and that’s where DeepInfra’s $0.30 rate beats Together’s $0.35.
Cost breakdown – Uncached input: 2,000M × $0.30/M = $600.00 – Cached input: 6,000M × $0.04/M = $240.00 – Output: 120M × $1.20/M = $144.00 – Total: $984.00/month (about $0.0049 per query)
Same workload on Together: $700.00 + $240.00 + $180.00 = $1,120.00, or $136.00 more.
| Volume | Model | Provider | Input tokens | Output tokens | Monthly cost |
|---|---|---|---|---|---|
| Local: ~6 h/day of agent work | Muse Glimmer 30B, 4-bit + DFlash | RTX 5090 (owned) | 900M (720M cached, 180M uncached) | 30M | $102.09 (fixed) |
| Burst: parallel sub-agents, CI, nightly evals | Muse Glimmer 30B | DeepInfra | 300M (240M cached, 60M uncached) | 10M | $39.60 |
| Total | $141.69 |
This is the workload Muse Glimmer was designed for. A developer runs the 4-bit build on their own RTX 5090 for day-to-day agent work: code edits, file operations and screenshots that never leave the machine. When the work fans out (ten parallel sub-agents, a CI run, an overnight eval sweep), the same model ID goes to DeepInfra, which handles the concurrency a single local GPU can’t. The local slice averages about 46 output tok/s over 180 active hours, well under the 233.4 tok/s Meta measured with the DFlash drafter.
Why DeepInfra fits: burst traffic is spiky, which is exactly what per-token billing with no minimums is for. You don’t pay for a second GPU that sits idle 20 hours a day.
Cost breakdown – Local hardware: $1,999 ÷ 24 months = $83.29 – Local power: 0.575 kW × 180 h × $0.1816/kWh = $18.80 – Burst uncached input: 60M × $0.30/M = $18.00 – Burst cached input: 240M × $0.04/M = $9.60 – Burst output: 10M × $1.20/M = $12.00 – Total: $83.29 + $18.80 + $39.60 = $141.69/month (estimate)
Same workload entirely on DeepInfra: $118.80 (local slice: $54.00 + $28.80 + $36.00) + $39.60 = $158.40, or $16.71 more than the hybrid. Entirely on Together: $136.80 + $45.60 = $182.40, or $40.71 more.
The hybrid saves $16.71 a month, which is real money but a thin margin. It depends on 24-month amortization, an existing host PC and six busy hours a day. Use the card less, or count the rest of the build, and all-cloud on DeepInfra comes out cheaper. The stronger reasons to go hybrid are privacy, offline work and latency on the local slice, not the invoice.
| Volume | Model | Provider | Input tokens | Output tokens | Monthly cost |
|---|---|---|---|---|---|
| 1,000,000 page images | Muse Glimmer 30B (Low) | DeepInfra | 2,400M (600M cached, 1,800M uncached) | 250M | $864.00 |
A backend turns invoices, forms and app screenshots into JSON with function calling. Each request carries one page image (assumed at about 1,600 visual tokens, under Meta’s 4,096 cap), 200 tokens of document-specific text, and a 600-token cached prefix of instructions and JSON schema, and returns 250 tokens of JSON. Reasoning strength is set to low because extraction doesn’t benefit from long thinking.
Why DeepInfra fits: image tokens are uncached input, the most expensive input type, and DeepInfra prices it lowest. JSON mode and function calling are both listed on the model page.
Cost breakdown – Uncached input (image + text): 1,800M × $0.30/M = $540.00 – Cached input (instructions + schema): 600M × $0.04/M = $24.00 – Output: 250M × $1.20/M = $300.00 – Total: $864.00/month (about $0.00086 per page)
Same workload on Together: $630.00 + $24.00 + $375.00 = $1,029.00, or $165.00 more.
If extraction quality holds up on a cheaper model, test Gemma 4 31B at $0.20 / $0.40 on the same pages. It also accepts images and is Flex-eligible.
| Volume | Model | Provider | Input tokens | Output tokens | Monthly cost |
|---|---|---|---|---|---|
| Customer-facing agents, steady 24/7 | Muse Glimmer 30B (High) | DeepInfra (per token) | 20,000M (12,000M cached, 8,000M uncached) | 1,000M | $4,080.00 |
| Same, on a private endpoint | Muse Glimmer 30B, BF16 | DeepInfra, 2 × H100 dedicated | n/a | n/a | $4,234.00 |
At 20B input tokens a month, teams start asking about dedicated capacity for predictable latency, isolation or custom weights. The average load here is about 3,000 uncached input tokens/second and 380 output tokens/second, and peaks run higher. This scenario assumes two H100s to cover the peaks. Measure your real throughput before you size anything.
Why DeepInfra fits: you can start on per-token and move to a dedicated endpoint on the same account when the numbers justify it. At this volume they don’t yet: per-token is $154.00 cheaper than two dedicated H100s, and only a single H100 ($2,117.00) carrying the full load, peaks included, would beat it.
Cost breakdown (per token) – Uncached input: 8,000M × $0.30/M = $2,400.00 – Cached input: 12,000M × $0.04/M = $480.00 – Output: 1,000M × $1.20/M = $1,200.00 – Total: $4,080.00/month
Cost breakdown (private endpoint) – 2 H100 × 730 h × $2.90/h = $4,234.00/month
Same workload on Together per token: $2,800.00 + $480.00 + $1,500.00 = $4,780.00, or $700.00 more. On two Fireworks on-demand H100s: 2 × 730 × $8.00 = $11,680.00, or $7,600.00 more.
Three numbers decide a Muse Glimmer bill: the output rate ($1.20 on DeepInfra vs $1.50 on Together), the cached-input rate ($0.04 at both) and your cache hit rate, which you control. Deployment needs come next. Pick Together if time to first token is your SLA, OpenRouter if you want one key and failover, and your own RTX 5090 if the work must stay on the machine.
For cost, DeepInfra is the cheapest hosted route. Flex isn’t offered on this model yet, so batch jobs don’t get a discount. If a step doesn’t need Muse Glimmer’s agentic strengths, Gemma 4 31B or Qwen3.6-35B-A3B on the same API costs less and supports Flex. For the specs and parameters, see the Muse Glimmer 30B model overview. For speed and latency by provider, see the Muse Glimmer 30B API provider benchmarks. For how a pricing guide plays out on a much larger model, the MiMo-V2.6-Pro pricing guide uses the same method. Speeds for new open models usually improve after launch (here’s why), so recheck the latency gap before you lock in a provider.
Start with Muse Glimmer 30B on DeepInfra, run your real prompt mix for a week, and read the cached-token share off your usage before you commit to a scenario. Startups can apply for free credits through DeepStart.
Granite-4.2-8B Pricing Guide: Provider Comparison<p>Granite-4.2-8b is a practical pick for anyone shopping for a small open-weight reasoning model. It costs $0.06 per million input tokens and $0.25 per million output tokens. It also scores 11 on the Artificial Analysis Intelligence Index among small (4B to 40B) open-weight models. Its input price sits below the $0.12 median for comparable models, […]</p>
Open-Source vs Closed-Source AI Models: Is the Gap Worth It?<p>The Artificial Analysis Intelligence Index sits at a ceiling of 57. Three frontier models — Claude Opus 4.7, Gemini 3.1 Pro Preview, and GPT-5.5 — all land in that band. Meanwhile, four open-weight models released between February and April 2026 now score 50 or above on the same index. A year ago, the best open-weight […]</p>
Small Open-Weight Models: The Hidden Cost Advantage<p>Qwen3.8-27B landed at #9 on Arena.ai’s Code Arena WebDev board with 1,595 points, and as of September 2026 it’s the only model under 30 billion parameters in the top 10. Gemma 4-31B, released the same year and larger by three billion parameters, sits at #80. Three ranks above the 27B sits Qwen3.8-2.4T-A95B, a sibling with […]</p>
© 2026 DeepInfra. All rights reserved.