Meta released three things under names close enough to blur together: Muse Spark in April, Muse Spark 1.1 in July, Muse Spark 1.2 and then Muse Glimmer five days apart in August. Only one of those is free to download. Only one runs on your own machine. And they’re not the same one, which is where most people get it backwards.
Here’s the short version before the details. Muse Spark is Meta’s closed, paid flagship model, the first thing to come out of Meta Superintelligence Labs. Muse Glimmer is a completely different, much smaller model that Meta released for free on Hugging Face, built to run on your own laptop instead of Meta’s servers. They share a training lineage, not a product page, and if you went looking for Spark’s weights expecting to download them, that’s actually the wrong model.
I’d been running a side project’s coding agent on Claude Opus for a few months and the API bill was starting to sting, so when Meta’s pricing showed up at roughly a quarter of that, I wanted to know if it actually held up or if the number was doing all the talking. That question doesn’t have a clean answer, and figuring out why took me longer than I’d like to admit.
What Muse Spark Actually Is
Muse Spark is a large language model built by Meta Superintelligence Labs, the research group Mark Zuckerberg formed after spending big to pull researchers away from OpenAI, Google DeepMind, and Anthropic through 2025.The lab is led by Alexandr Wang, the former CEO of Scale AI. Meta announced Spark on April 8, 2026. It wasn’t a Llama update. It’s a complete departure from the Llama family, an entirely new architecture, and unlike the open Llama models before it, Spark launched closed source, which is a big shift for a company that spent years positioning itself as the open-weight alternative to OpenAI and Google.
At launch it was a compact model by design. Meta framed it as the first step in a deliberate scaling ladder, small and fast on purpose, with each generation meant to validate before the next one goes bigger. It went straight into Meta’s own products first. It started powering the Meta AI app and website, then rolled out to WhatsApp, Instagram, Facebook, Messenger, and Meta’s AI glasses. API access stayed locked behind a private preview for select partners for three months.
Then in July, the pace picked up. Muse Spark 1.1 launched July 9 and this is where things start actually mattering for anyone outside Menlo Park. 1.1 is built for personal agentic tasks, planning and orchestrating across external apps and services, and it zero-shot generalizes to new tools, MCP servers, and custom skills. It can run as the main agent, breaking down a task and handing pieces to subagents, or as a subagent itself, which is the part that actually matters if you’re building anything more complex than a chatbot.
The context window is the headline spec. That’s not marketing padding either. 1.1 accepts text, images, video, audio, and PDF documents, and returns text, with a 1,048,576 token context window. It manages that million-token window actively instead of passively, compacting older material while keeping the steps that matter for later work, so a long agentic session on a big codebase doesn’t lose the thread mid-refactor the way older models did. I’ve had exactly that problem with other tools losing context halfway through a multi-file change, so this is one of the few “agentic” claims that actually addresses something real.
Pricing is where Meta got aggressive. Spark 1.1 launched at $1.25 per million input tokens and $4.25 per million output tokens, roughly a quarter of what Anthropic and OpenAI were charging for their flagship models at the time. Cached tokens are even cheaper. The cached input rate is $0.15 per million, an 88% discount off standard input, and there’s no long-context surcharge, so the price per token doesn’t creep up as your context fills. If you’re running an agent that resends the same system prompt and tool schema on every turn, that cache discount alone changes the monthly bill.
August brought Spark 1.2, and this is the one people are actually searching pricing for right now. 1.2 shipped August 5 alongside Muse Code, a beta terminal coding agent co-trained with the model. Standard pricing didn’t move. It’s still $1.25 input, $0.15 cached input, $4.25 output per million tokens, same 1,048,576 context. The actual news is a second tier Meta added underneath it. There’s now a “contributor” tier at $0.10 input and $0.20 output, a discount of over 12x on input and 21x on output, in exchange for letting Meta train future models on your prompts and completions, capped at 60 requests per minute against the standard tier’s 3,000. That’s a real trade, not a rounding error, and I’d guess most solo developers take it without reading the fine print.
What Muse Glimmer Actually Is
This is the one that confused me too the first time I read about it. Muse Glimmer is not a smaller version of the Meta AI app model. It’s a separate release, dropped five days after Spark 1.2, aimed at a completely different use case: running an agent on your own machine with no server call at all.
The lineage matters here. It’s not trained from scratch. It comes from Spark 1.2, inheriting most of that model’s reasoning ability in a package small enough to fit on a laptop. Technically, the pre-training phase used logit distillation on Spark’s own outputs, with a data mix similar to the teacher model, to produce the compact base.
The number that actually matters, the one that decides whether this runs on your hardware or not: once quantized to 4-bit, the model drops below 20 gigabytes, which fits in the memory of a single 24 or 32 GB consumer graphics card, so it doesn’t need a data center to run. A 30B model at full precision would normally choke a consumer GPU. At full precision a 30B model needs over 55 GB of memory; Meta compresses it to roughly 4-bit and adds block-level speculative decoding so it answers fast enough to sit inside a real agent loop. Meta calls that speculative decoder DFlash, and it’s not a small speedup either. The combination fits 24 GB VRAM at about 1% degradation and decodes 3.1x faster on an RTX 5090.
I’ll admit I didn’t expect the “no internet needed” claim to be literal, but it is. It works with or without a connection, and targets the workloads that matter for agents: function calling, local coding, long tool-use sessions, and LLM-as-a-judge evaluation. It’s also not text-only. It has a dedicated perception encoder, so it reads text, images, screenshots, charts, and documents, which is why Meta calls it “agentic” rather than just a chat model. It’s tuned to finish tasks start to finish, call tools precisely, and recover when something breaks, not just answer questions. Context tops out lower than Spark, at 131,072 tokens, which is still plenty for most codebases people actually work in day to day.
The Hugging Face collection ships BF16 weights for fine-tuning, GGUF k-quants for llama.cpp, and ExecuTorch builds for on-device inference, alongside the DFlash drafter.
Tooling support isn’t fully baked yet, though. Optimized integrations for llama.cpp, MLX, and ExecuTorch were still landing “in the coming days” at launch, and support through Ollama, LM Studio, Together AI, and Fireworks AI was also still rolling out. Documentation itself was thin at launch, if I’m honest. If you tried to run it the day it dropped and hit rough edges, that’s why: it wasn’t fully cooked on release day, which happens more than model release blog posts like to admit.
Worth a mention, since it’s the kind of loose thread that never makes it into the official post: this release landed right after Meta was hit with roughly a billion dollars in child-safety related fines, with a New Mexico judge finding the company hadn’t warned the public about risks on its platforms. I don’t think that’s the reason Glimmer exists, engineering teams don’t work that fast, but the timing didn’t go unnoticed by people I follow on this stuff.
Making Sense of the “People Also Search For” Cluster
Since that’s basically what sent you down this hole in the first place, let me untangle it properly.
The confusion starts with use and download sitting right next to each other in that search list, because they point to two different products. You can’t download Spark. It’s closed weights, API-only, and the free way to use it is through the Meta AI app or the meta.ai website. If your intent was to get weights on your own machine, you actually wanted Glimmer the whole time. It will only take a minute to see the split once you know what each product is actually for. Search for Spark on Hugging Face and you’ll come up empty, because there’s nothing there under that name. What you’ll actually find is Glimmer, sitting in the meta-models org, which is probably where that download search should have landed you in the first place.
Pricing is more straightforward, and the 1.1-specific searches probably come from people who found stale pre-launch estimates and wanted the number confirmed after the July 9 rollout. It’s $1.25 per million input tokens and $4.25 per million output, with cached input dropping to $0.15. That held steady through the 1.2 release in August, so anyone still quoting older numbers is behind.
The API search is where people usually hit a wall they didn’t expect. Access is currently limited to developers in the United States, and routing through OpenRouter doesn’t get around that either, since OpenRouter enforces the same country gate on its own model page. A bunch of people ran into this on launch day and said so publicly, which is probably why “Muse Spark API” keeps showing up as a search on its own instead of folded into “how to use.” OpenRouter itself is live for 1.1 at the same rates as Meta’s direct API. 1.2’s own OpenRouter route is a different story. Meta’s product pages link to one, but as of the most recent check I found, it wasn’t actually live on OpenRouter’s side yet. So if you searched that expecting a working route today, you might just be a few days early.
The CLI search is really about a different product wearing Spark’s name. Muse Code is the terminal coding agent Meta shipped alongside 1.2 on August 5, co-trained with the model instead of bolted on afterward. It’s still in beta, so don’t go in expecting it to match something like Claude Code or Codex CLI feature-for-feature yet.
People keep treating Spark and Glimmer as one product with two names, probably because Meta’s own developer blog links between the two pages without ever spelling out the difference. Even Meta’s press team seems to default to whichever model shipped most recently whenever a reporter asks a general question about “the Muse models.” That’s on Meta’s naming, not on you for getting tangled up in autocomplete.
Muse Spark and Muse Glimmer Against the Rest of the Field
The marketing and the independent numbers start to disagree a bit, which honestly makes it more useful to look at.
Meta’s own release table for Spark 1.1 shows some strong wins. On MCP Atlas, a test of scaled tool use, it scores 88.1, ahead of both Claude Opus 4.8 and GPT-5.5, which sit in the high 70s and low 80s. On JobBench, a professional tool-use benchmark, it hits 54.7 against Opus 4.8’s 48.4 and GPT-5.5’s 38.3, and that gap is wide enough that it’s the standout number in the whole release. It also leads Humanity’s Last Exam with tools at 62.1, ahead of Opus 4.8’s 57.9.
But coding, the thing most people actually search Spark for, is a mixed bag once you get past Meta’s own chart. On Terminal-Bench 2.1, GPT-5.5 leads. On SWE-Bench Pro, Claude Opus 4.8 leads. On DeepSWE 1.1, GPT-5.5 leads. TechJack Solutions ran the numbers more precisely and found Claude Opus 4.8 scores 69.2% on SWE-Bench Pro against Spark 1.1’s 61.5%, though Spark still beats GPT-5.5’s 58.6% and Gemini 3.1 Pro’s 54.2% on the same test. Terminal-Bench tells a similar story: on the 2.1 suite, Spark 1.1 scored 80.0, close behind Opus 4.8’s 82.7 and GPT-5.5’s 83.4. That’s a real improvement from where Spark started. It’s not the leader, but it closed a gap that used to be embarrassing.
Where Spark actually falls apart is abstract reasoning outside its coding-and-tools lane. On ARC-AGI-2, a test of novel-pattern reasoning, Spark 1.1 scores 42.5 against GPT-5.4’s 76.1 and Gemini 3.1 Pro’s 76.5. That’s not a close race. That’s a different tier. So if your work leans toward novel problem-solving rather than a known toolchain, Claude or GPT is still the safer pick. I’d trust Spark for a well-scoped coding task inside a familiar stack and not much beyond that.
Glimmer’s story is more interesting because it’s competing in a different weight class entirely: local models you can actually run yourself. Against Qwen3.6–27B, its closest rival, it’s a genuine trade rather than a sweep. It beats Qwen3.6–27B on SWE-Bench Pro and by 13 points on MCP Atlas tool use, but loses to it on TerminalBench 2.1. Qwen takes SWE-Bench Verified 77.2 to 76.0, and TerminalBench 2.1 by nine points, 60.7 to 51.7, which is the benchmark closest to actually driving a shell. One thing that surprised me: Glimmer’s hallucination rate is rough. Its knowledge calibration comes in low for its intelligence level, driven by an 82% hallucination rate against Qwen3.6 27B’s 49%, though accuracy on questions it does answer matches its peers. That’s not a small gap, and if you’re running it for anything where a confident wrong answer is costly, it’s worth knowing going in.
A hands-on test run by the AI blog Kingy.ai backs up the practical side of things rather than just the leaderboard. On a 24GB M4 Pro Mac, Glimmer ran fine as a local agent and recorded three passes, two partials, and two failures across a seven-task test. The official Qwen3.6–27B build didn’t survive first decode on that same Mac. So even where the benchmark scores are close, the actual experience of getting a model running on consumer hardware can tip things in Glimmer’s favor, at least until Qwen’s tooling catches up on Apple silicon.
Against DeepSeek’s line, the comparison is less direct since DeepSeek plays in a bigger weight class. DeepSeek-V4-Pro-Max scores 80.6% on SWE-Bench Verified at 1.6T parameters with 49B active, well ahead of Glimmer’s 30B dense setup, but that’s also a model that won’t fit on a single consumer GPU the way Glimmer will. If your constraint is “one 24GB card, no data center,” Glimmer and Qwen3.6 are really the two options worth cross-shopping, not DeepSeek.
Should You Actually Use Either One
My suggestion would be. If you’re building an agent workflow with tool calls and you care about cost per completed task more than winning every leaderboard, Spark 1.1 or 1.2 is worth piloting. The pricing gap isn’t small, a quarter of what Opus 4.8 or GPT-5.5 charge, and for a workflow that burns tokens fast, that difference compounds every single day. Just don’t expect it to replace Claude or GPT for hard, novel problems. It wasn’t built for that lane, and the ARC-AGI-2 number makes that obvious.
For local, Glimmer earns its spot if you already have a 24GB card sitting around or a newer Mac and want something that doesn’t phone home. It’s not a clean win over Qwen3.6, it loses on raw coding benchmarks, but it’s stronger on tool use and, in the one hands-on test I found, it actually ran on hardware where Qwen’s official build choked. That’s a real advantage if you’re not spending your weekend debugging quantization formats. What I’d watch is that hallucination number. An agent that’s wrong 82% of the time it doesn’t know something is an agent you still need to babysit, not one you set running and walk away from.
We can also Pilote Spark 1.2’s contributor tier for a low-stakes internal tool, since giving up training rights for a 12x discount made sense for something that doesn’t touch client data, and we can holding off on Glimmer until the tooling forllama.cpp and MLX finishes rolling out properly. That’s probably the reasonable move for most small teams right now. Both models are still new, the ecosystem around them is still catching up, and Meta shipped three things in four months under names close enough to trip up Google’s own autocomplete. Give it another month before you bet a production workflow on either one.