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

Muse Glimmer 30B Pricing Guide: API Costs vs Running It Yourself - Deep Infra

Published on 2026.11.16 by DeepInfra
Muse Glimmer 30B Pricing Guide: API Costs vs Running It Yourself - Deep Infra

Muse Glimmer 30B Executive Summary

Best forProvider recommendationWhy
Lowest per-token priceDeepInfra$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 tokenTogether AITime 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 failoverOpenRouterRoutes between DeepInfra and Together at their own token prices; “Floor” mode picks the cheapest, “Nitro” the fastest
RAG and cache-heavy agentsDeepInfraCached 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 callTogether AIOpenRouter lists a 117,964-token completion cap for Together vs 16,384 for DeepInfra
Offline, private or single-user agentsSelf-host the 4-bit buildApache 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.)

Understanding Tokens and How You’re Charged

Token typeWhat it isWhy 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 inputPrompt 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
OutputGenerated tokens, including reasoning$1.20/M on DeepInfra, 4× the input rate. Higher reasoning strength produces more of them
Image inputImages pass through Meta’s perception encoder and become visual tokensMeta caps an image at 4,096 visual tokens. Billed as input at $0.30/M, a maximum-size image costs about $0.0012
Max completionThe ceiling on output tokens per request16,384 on DeepInfra per OpenRouter’s listing; long generations need to be split across calls
Context windowPrompt plus output, per request131,072 tokens. Long-context RAG has to fit inside it; there’s no 1M-token mode

What this means in practice:

  • Agent traffic is input-heavy. When Artificial Analysis ran its Intelligence Index, Muse Glimmer read 2.24B input tokens and wrote 39.5M output tokens, so output was under 2% of input. For agent workloads, your cached-input rate and cache hit rate matter more than the headline output price.
  • Reasoning strength is a cost dial. Muse Glimmer has four levels (low, medium, high, xhigh), set in the system prompt. Meta recommends high or xhigh for coding and agentic work. AA’s figures are for High. Use low for extraction and classification, where the extra reasoning tokens buy little.
  • Concision helps. Because the model writes about half the output tokens of a typical model in its class on AA’s index, its effective cost per task is lower than its rate card suggests. AA puts it at $0.18 per Intelligence Index task.
  • Keep prompts cache-friendly. Put the system prompt, tool definitions and stable documents first and the changing content last. OpenRouter reports DeepInfra’s effective input price for this model at $0.0721/M with an 87.6% cache hit rate, which shows what disciplined prompt structure does to a $0.30 list rate.

Provider Token Cost Tradeoffs

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 / routeInput /1MOutput /1MCached /1MAdvantageDisadvantageBest fit
DeepInfra (Standard)$0.30$1.20$0.04Lowest listed rate on all three token types; zero data retention; JSON and function calling; served at BF16 per OpenRouterSlower to first answer token than Together; 16,384-token completion cap; no Flex tier on this model yetCost-sensitive production, RAG, extraction
Together AI$0.35$1.50$0.04Fastest time to first answer token; 117,964-token completion cap17% higher input and 25% higher output priceInteractive chat and streaming UIs, very long single outputs
OpenRouter, standard routingSame as the provider it routes toSameSameOne API key, automatic failover, “Floor” (cheapest) or “Nitro” (fastest) routingOpenRouter’s own platform fees and terms apply on topTeams already on OpenRouter, or wanting failover between both hosts
OpenRouter :batch variant (served by DeepInfra)$0.24$0.96$0.032Lowest per-token rate listed anywhere for this modelOnly via OpenRouter; batch behavior is set by OpenRouter, not DeepInfra’s direct APIOffline jobs already routed through OpenRouter
Fireworks on-demandn/a (per GPU-hour)n/an/aDedicated capacity, fine-tuning on the same platformNo serverless option; H100 at $8.00/hourTeams fine-tuning on Fireworks
DeepInfra dedicated GPUn/a (per GPU-hour)n/an/aYour own endpoint; A100 80GB at $1.49/hour, H100 at $2.90/hourYou pay for idle time and size it yourselfSteady, high, predictable volume
Self-hosted (RTX 5090, 4-bit)$0 marginal$0 marginal$0 marginalOffline, data never leaves the machine; Meta reports 233.4 tok/s with the DFlash drafterHardware and power cost; batch-size-1 speed; 4-bit build loses about 1% on Meta’s averageSingle-developer local agents, air-gapped work

Takeaways by workload:

  • Per-token, DeepInfra is cheapest on every line. The gap is widest on output ($1.20 vs $1.50) and disappears on cached input, where both hosts charge $0.04. The more cache-heavy your workload, the closer the two bills get.
  • If time to first token is your SLA, Together is the better host today. On Artificial Analysis, Together’s time to first answer token is 18.5 s vs 28.8 s on DeepInfra (High reasoning, so this includes thinking time), and its time per Intelligence Index task is 4.9 vs 5.1 minutes. Sustained output speed is close: AA measures 89 tok/s for Together and 86 tok/s for DeepInfra. OpenRouter’s one-week median shows Together with lower latency (0.50 s vs 0.71 s) and DeepInfra with higher throughput (90 vs 64 tok/s), so treat throughput as a tie that moves week to week, and latency as Together’s edge.
  • Self-hosting is a utilization bet. It wins when one GPU stays busy for hours a day. The break-even math is in the next section.

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.

OpenRouter routing

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.

Self-hosting: when does your own GPU beat per-token pricing?

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):

OptionMonthly fixed costBreak-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 80GB730 × $1.49 = $1,087.70~5.23B tokens/month~1,990 mixed tok/s (~199 output tok/s) around the clock
DeepInfra dedicated H100730 × $2.90 = $2,117.00~10.18B tokens/month~3,873 mixed tok/s (~387 output tok/s) around the clock
Fireworks on-demand H100730 × $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:

  • A local RTX 5090 is cheap to own but serves one stream at a time. At 233.4 tok/s, running nonstop for a month, it could generate about 613M output tokens, which would cost about $736 at DeepInfra’s output rate. Nobody runs a desk GPU at 100%, though. For one developer whose agent works a few hours a day, the card is close to break-even (Scenario 3 has the numbers). It doesn’t scale to a team: 10 developers sharing one card at batch size 1 will queue.
  • Rented GPUs need sustained traffic. A dedicated A100 only beats per-token pricing if you push about 2,000 tokens/second through it around the clock, peaks included. Most teams don’t, and per-token billing charges nothing for idle hours.
  • Fireworks on-demand is the expensive way to self-serve. At $8.00/hour per H100, it needs nearly 3× the volume of a DeepInfra H100 to break even.

DeepInfra: The Lowest-Cost Hosted Route for Muse Glimmer 30B

Model / listingBest use caseContextInput /1MOutput /1M
Muse Glimmer 30BAgents, tool calling, coding agents, screenshot and document understanding131,072$0.30 ($0.04 cached)$1.20
Gemma 4 31BCheaper multimodal general tasks; Flex-eligible ($0.16 / $0.32)262,144$0.20$0.40
Qwen3.6-35B-A3BCheap high-volume steps, long context; Flex-eligible262,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.

Real-World Cost Scenarios for Developers

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.

Scenario 1: Repo-scale coding agent for a 25-person team

VolumeModelProviderInput tokensOutput tokensMonthly cost
25 developers, agent sessions dailyMuse Glimmer 30B (High)DeepInfra2,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.

Scenario 2: Long-context RAG over a support knowledge base

VolumeModelProviderInput tokensOutput tokensMonthly cost
200,000 queriesMuse Glimmer 30B (Medium)DeepInfra8,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.

Scenario 3: Local agent with cloud burst

VolumeModelProviderInput tokensOutput tokensMonthly cost
Local: ~6 h/day of agent workMuse Glimmer 30B, 4-bit + DFlashRTX 5090 (owned)900M (720M cached, 180M uncached)30M$102.09 (fixed)
Burst: parallel sub-agents, CI, nightly evalsMuse Glimmer 30BDeepInfra300M (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.

Scenario 4: Screenshot and document extraction to JSON

VolumeModelProviderInput tokensOutput tokensMonthly cost
1,000,000 page imagesMuse Glimmer 30B (Low)DeepInfra2,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.

Scenario 5: Production agent platform: per-token vs private endpoint

VolumeModelProviderInput tokensOutput tokensMonthly cost
Customer-facing agents, steady 24/7Muse Glimmer 30B (High)DeepInfra (per token)20,000M (12,000M cached, 8,000M uncached)1,000M$4,080.00
Same, on a private endpointMuse Glimmer 30B, BF16DeepInfra, 2 × H100 dedicatedn/an/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.

What these scenarios say about DeepInfra

  • DeepInfra was the cheapest hosted route in all five scenarios, by 11% to 16% against Together. The savings come from uncached input and output, not from the cache.
  • Cache discipline matters more than provider choice. Both hosts charge $0.04 for cached input, and in Scenario 1 a broken cache costs more ($182.00/month) than switching providers saves ($27.00).
  • Together is the pick when first-token latency is the requirement, or when you need single responses longer than 16,384 tokens. Paying 11% to 16% more for a 10-second faster first answer at High reasoning is a reasonable trade for interactive products.
  • Self-hosting is close to break-even for one heavy user and loses at team scale. Muse Glimmer’s 4-bit build makes local agents practical, and cloud burst on DeepInfra covers the parallel work a single GPU can’t.
  • Dedicated GPUs only win with sustained, measured throughput. At 20B input tokens a month, per-token billing still beats two dedicated H100s.

Conclusion

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.

Related articles
Granite-4.2-8B Pricing Guide: Provider ComparisonGranite-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, [&hellip;]</p>
Open-Source vs Closed-Source AI Models: Is the Gap Worth It?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 [&hellip;]</p>
Small Open-Weight Models: The Hidden Cost AdvantageSmall Open-Weight Models: The Hidden Cost Advantage<p>Qwen3.8-27B landed at #9 on Arena.ai&#8217;s Code Arena WebDev board with 1,595 points, and as of September 2026 it&#8217;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 [&hellip;]</p>