Muse Spark 1.1 Is on Writingmate: Testing Meta's First Paid Agentic Model on Coding and Computer-Use Tasks

Meta shipped Muse Spark 1.1 on July 9 and then went almost silent about it. No flashy keynote, no Zuckerberg livestream, just a model card, a pay-per-token API, and a 1M-token context window quietly showing up in the Writingmate model picker. Meanwhile every other frontier release from the last few weeks — DeepSeek V4 Pro, Kimi K3, Mistral Large 3, Inkling — got its own hands-on post from me within days of launch. Muse Spark 1.1 sat there untested for three weeks. That's on me, and I'm fixing it today.

My name is Artem, I run the model-testing side of the Writingmate blog, and I've now put every one of those frontier releases through the same broken-function, messy-refactor, multi-step agentic test suite. Muse Spark 1.1 is the first Meta model in that lineup, and it's also the first time Meta has charged per token for a Model API instead of giving everything away as open weights. That alone made me curious whether the quality matches the price tag, so I ran it against the same tasks I used on DeepSeek V4 Pro, Kimi K3, and Mistral Large 3, plus one new test: a multi-agent orchestration job, since Meta's own pitch for Muse Spark 1.1 leans hard on "delegate to and escalate from subagents."

What Muse Spark 1.1 Actually Is

Muse Spark 1.1 is Meta's first model released under a straight pay-per-token Model API rather than the open-weights-plus-Llama-license approach the company has leaned on since Llama 2. That's a real shift. It's a multimodal agentic model — text, images, and structured tool calls in one context — built around a 1M-token window, which puts it in the same bracket as Gemini's long-context tier rather than the 128K-256K windows most "agentic coder" models ship with.

The headline feature isn't the context window, though. It's the orchestration layer. Meta's documentation describes Muse Spark 1.1 as able to spin up subagents for isolated subtasks — say, one subagent scoped to reading a repo's test suite while the parent agent handles the actual code edit — and then escalate back to a larger reasoning pass if a subagent reports low confidence. That's a genuinely different architecture pitch than "one big model, bigger context." It's closer to how Claude's agent tooling or OpenAI's Assistants-style orchestration works than to a single dense chat model.

Pricing is the other headline: Meta priced the Model API at roughly a quarter of what OpenAI and Anthropic charge for comparable frontier tiers. On paper that's the kind of gap that changes buying decisions, so I wanted to know if the output backs it up before recommending anyone route production traffic to it.

How I Tested It

I used the same three-part suite I've run on every recent frontier model, plus a fourth test built specifically for Muse Spark 1.1's orchestration claim:

• Broken function repair — a Python function with a subtle off-by-one bug and a misleading docstring, no hint given about where the bug is.
• Messy refactor — a 400-line file with duplicated logic, inconsistent naming, and no tests, with instructions to refactor without changing behavior.
• Multi-step agentic task — read three files, cross-reference a config value, and make a coordinated edit across two of them, using tool calls rather than one-shot generation.
• Multi-agent orchestration — a task explicitly structured to reward delegation: audit a mid-size repo for three unrelated issues (a lint violation, a missing test, and a broken import) and report back with a single consolidated summary.

I ran each test three times per model to check for consistency, using the same prompts across DeepSeek V4 Pro, Kimi K3, Mistral Large 3, Inkling, and Muse Spark 1.1, all inside Writingmate so the harness and system prompt stayed identical. That last part matters — model comparisons that use different scaffolding for each model aren't really comparing the models.

Coding Tests: Where Muse Spark 1.1 Held Up and Where It Didn't

On the broken-function test, Muse Spark 1.1 found the off-by-one bug on the first pass in two of three runs, and on the third run it flagged the wrong line first but self-corrected after I asked it to re-check its reasoning. That's roughly in line with Mistral Large 3, a step behind DeepSeek V4 Pro (which nailed it three-for-three), and noticeably better than Inkling, which needed a second nudge every time.

The messy refactor is where the model's personality showed up. Muse Spark 1.1 didn't just clean up the duplicated logic — it added inline comments explaining why it consolidated two near-identical functions, which is exactly the kind of small touch that makes a refactor easier to review later. Kimi K3 produces the cleanest diff of the group, but Muse Spark 1.1's version was the easiest to hand off to another engineer without extra context. It did occasionally over-explain, adding a short summary paragraph nobody asked for, which got repetitive across the three runs.

The multi-step agentic task — read three files, cross-reference a config, edit two files coherently — is where the 1M-token window actually earned its keep. Muse Spark 1.1 pulled in more surrounding context than it needed and used that context correctly, catching a naming inconsistency between two files that DeepSeek V4 Pro missed entirely in one of its runs. If your work involves large codebases where relevant context is scattered across many files, that window size is a real practical advantage, not just a marketing number.

The Multi-Agent Orchestration Test

This is the test I built specifically for Muse Spark 1.1's pitch, and it's also the most interesting result. I asked it to audit a repo for three unrelated issues and produce one consolidated report. Muse Spark 1.1 visibly split the work: it spawned what its own trace labeled as three separate sub-passes, one per issue type, then merged the findings into a single summary with a confidence note on each item. When I deliberately introduced a red herring — a lint rule that looked broken but wasn't — the escalation behavior kicked in and it flagged that finding as "low confidence, recommend manual review" instead of reporting it as fact.

None of the other four models did anything like that natively. DeepSeek V4 Pro and Kimi K3 both produced a single linear pass through all three issues, which worked fine but didn't self-flag uncertainty the way Muse Spark 1.1 did. Mistral Large 3 handled the task well but treated it as one undifferentiated job. For anyone building actual agent pipelines rather than just chatting, that self-escalation behavior is the most useful thing I found in this whole test round — it's a meaningfully different failure mode than the usual "confidently wrong" pattern.

Price and Performance Against the Rest of the Frontier

Meta's quarter-of-frontier-pricing claim is the reason I bumped this review up the queue. Here's how the numbers and my test results stack up against the other models I've reviewed this month.

Model	Context window	Broken-function fix rate	Agentic multi-step	Relative API cost
Muse Spark 1.1	1M tokens	2/3 first-pass	Strong, best context use	~1x (baseline, roughly a quarter of GPT/Claude tier)
DeepSeek V4 Pro	256K tokens	3/3 first-pass	Strong, minor context miss	~0.9x
Kimi K3	256K tokens	2/3 first-pass	Solid, cleanest diffs	~1.1x
Mistral Large 3	128K tokens	2/3 first-pass	Solid, no orchestration	~1.4x
Inkling	200K tokens	1/3 first-pass, needed nudge	Adequate, slower	~0.8x

Read that table with the pricing caveat in mind: "roughly a quarter of OpenAI/Anthropic rates" is Meta's own positioning against the very top of the market, not against these mid-tier open and semi-open competitors, which are already priced aggressively. Against DeepSeek V4 Pro and Kimi K3 specifically, Muse Spark 1.1 isn't dramatically cheaper — it's competitive. Where it wins is the combination of window size and the orchestration behavior, not raw cost per token.

What the Community Is Saying

I'm not the only one who noticed Muse Spark 1.1 launched quietly. The early reaction on r/LocalLLaMA has been more about the licensing shift than the benchmarks:

"Meta going pay-per-token instead of open weights is the actual story here, not the 1M context. Feels like they're testing whether the API business can fund the open releases instead of the other way around." — u/context_窗口 on r/LocalLLaMA

On X, the reaction has been more focused on the subagent architecture, which tracks with what I found in testing:

"Muse Spark's subagent escalation is the first time I've seen a model flag its own low-confidence output instead of just hedging in the text. Small thing, big deal for pipelines." — @agentic_ml on X

Both reactions line up with what I saw hands-on: the pricing model shift matters more than the raw numbers suggest, and the orchestration behavior is the actual differentiator, not a marketing line.

Should You Actually Use It?

If your work is single-shot coding help — fix this function, explain this error — DeepSeek V4 Pro still edges it out on raw first-pass accuracy, and it's already covered in my DeepSeek V4 Pro agentic coding test. If you're comparing it against Mistral's return to the frontier conversation, that's in my Mistral Large 3 review. But if you're building something with actual delegation — a pipeline where one pass audits and a second pass fixes, or where you want a model to flag its own uncertainty instead of guessing — Muse Spark 1.1 is the strongest option I've tested this month for that specific job. You can pull it up directly from the Writingmate model picker under Meta, run it against your own repo, and switch to any of the other four models mid-conversation if you want a side-by-side without paying for four separate subscriptions. That side-by-side switching is honestly the fastest way to figure out which model fits your specific codebase — benchmarks tell you the average, your repo tells you the truth. If you're on the fence about which plan gets you API-level access to it, the pricing page breaks down what's included at each tier.

My honest take: Meta didn't ship a dramatically cheaper model, and it didn't ship the single best coder either. It shipped the first model in this batch that actually behaves differently when you hand it a job requiring delegation, and for agent-building work specifically, that's worth the three weeks of attention I'm late in giving it.

See you in the next one!

Artem