TL;DR: Meta’s first proprietary model, Muse Spark, is closed-source and API-only — a break from the Llama heritage. But it is a general-purpose model, not a coding model, and Llama 4 remains downloadable today, so your Cline/Cursor/Continue.dev BYOK setup changes by exactly zero this week. The real lesson: “Meta = open source” was always a marketing line, not a license, and the genuinely permissive coding backends worth relying on aren’t from Meta at all.

	Qwen3-Coder-Next	GLM 5.2	Codestral 2
License	Apache 2.0 (no strings)	MIT (no strings)	Apache 2.0 (no strings)
API cost (in/out per 1M)	~$0.11 / ~$0.80	~$1.40 / ~$4.40	~$0.30 / ~$0.90
Local fit	24GB GPU + RAM offload	Multi-GPU or API	16GB GPU at Q4
The catch	7th among open models on SWE-bench	Heavy to self-host	22B — weaker on hard multi-file work

Honest take: Do not migrate anything this week. Do spend ten minutes confirming you have an Apache-2.0 or MIT coding backend wired as a fallback — because unlike Llama’s Community License, those two actually let you ship without asking anyone’s permission.

---

What actually happened

On April 8, 2026, Meta released Muse Spark, the first model out of Meta Superintelligence Labs (MSL) — the unit Meta assembled under Alexandr Wang after spending roughly $14.3 billion for its stake in Scale AI. Muse Spark is natively multimodal and introduces a “Contemplating” reasoning mode that runs sub-agents in parallel, a direct answer to Google’s Gemini Deep Think and OpenAI’s extended-reasoning tiers. It now powers Meta AI across the company’s apps.

The headline for developers is the licensing model, not the capability: Muse Spark is closed source. Meta is offering it only in a private preview to select partners through an API. That makes it, in one sense, more locked down than the paid models from OpenAI and Anthropic, which at least publish public API access. It is a clean break from the Llama pattern of shipping downloadable weights.

The story resurfaced this week for a reason. On July 7, 2026, Meta launched Muse Image (internally code-named “Mango”) across the Meta AI app, Instagram Stories, and WhatsApp, with Muse Video announced as coming soon. Both are MSL models, both are closed, and Muse Image immediately drew a privacy backlash over a feature that lets you @-mention an Instagram account and pull that person’s likeness into a generated image. The pattern is now unmistakable: every new MSL model ships closed.

On Meta’s own numbers, Muse Spark lands fourth on the Artificial Analysis Intelligence Index v4.0 with a score of 52 — behind Gemini 3.1 Pro Preview and GPT-5.4 (both 57) and Claude Opus 4.6 (53). Respectable, not category-defining, and — critically for this audience — not a dedicated coding model.

Why a non-coding model matters to coders anyway

If Muse Spark were just another general-purpose chatbot model, developers could ignore it. The reason it matters is signal, not substance.

For three years, “download the weights and run it yourself” was Meta’s differentiator. Llama 1 through Llama 4 gave the local-AI and BYOK (bring-your-own-key) crowd a fallback that no cloud provider could switch off. A large slice of the “run a local LLM as your Cline or Cursor backend” ecosystem was built on that assumption — that Meta, whatever else it did, would keep shipping open weights.

Muse Spark says otherwise. MSL’s flagship line is proprietary. That does not retroactively close Llama 4, but it does tell you where the frontier investment is going: into a model you cannot download. For anyone architecting a coding stack around resilience — the ability to keep working if a vendor pulls access overnight, which we watched happen to Claude Fable 5 during its June export-control suspension — that is the part worth internalizing.

The uncomfortable truth: Llama was never actually “open source”

Here is the correction that most coverage skips, and it changes the whole risk calculus.

Llama models have never shipped under an OSI-approved open-source license like Apache 2.0 or MIT. Llama 4 ships under the Llama 4 Community License Agreement, which is source-available with real strings attached:

• The 700M-MAU cap. Companies with more than 700 million monthly active users must request a separate license from Meta, which Meta can grant or deny at its sole discretion.
• Mandatory attribution. If you distribute Llama Materials or a product containing them, you must prominently display “Built with Llama.”
• EU carve-out. The multimodal Llama 4 models cannot be used by, or distributed to, individuals or companies domiciled in the EU. The text-only paths are not blocked, but vision is off-limits for EU deployments without bespoke arrangements.

So the framing of “Meta abandons open source with Muse Spark” is only half right. Meta abandoned source-available downloadable weights at the frontier. It never gave you true open source in the first place. If you built a commercial product on Llama 4 assuming Apache-style freedom, you were already exposed — Muse Spark just makes the direction of travel explicit.

This matters because the coding backends people reach for as “the open alternative” are not all created equal. Some are genuinely permissive; Llama is not one of them.

What changes for your Cline / Cursor / Continue.dev setup today: nothing

Let’s be concrete, because panic is the wrong response.

• Llama 4 Scout and Maverick remain downloadable on Hugging Face and llama.com as of July 9, 2026. Scout is ~109B total (16 experts, ~17B active, 10M-token context); Maverick is ~400B total (128 experts, ~17B active, 1M context). Nothing about Muse Spark’s release pulled them.
• Your existing local setups still work. If you followed our Aider + local Ollama guide or wired a model through an OpenAI-compatible endpoint in Cline or Continue.dev, none of that broke this week.
• Muse Spark isn’t in any coding tool. It’s private-preview, API-only, and not positioned for code. There is no Cursor or Cline dropdown entry to lose.

If your workflow does not specifically depend on a Meta-released model, this news is a prompt to check your fallbacks, not to change a single config line.

The forward-looking risk — and the backends that actually de-risk it

The scenario worth planning for is not “Llama 4 disappears tomorrow.” It’s “the next generation of models you’d have downloaded follows Muse Spark into closed weights.” If that happens, you want a coding backend that is (a) genuinely permissively licensed, (b) available today, and (c) good enough for your real work.

The good news: the open-weight coding ecosystem is far broader than Meta, and the best options carry cleaner licenses than Llama ever did. Here are the audited alternatives, most permissive-and-practical first.

Backend	License	Params	API cost (in/out per 1M)	Runs locally on	Best for
Qwen3-Coder-Next	Apache 2.0	80B total / 3B active	~$0.11 / ~$0.80	24GB GPU + RAM offload	Cheapest credible agentic loops
Codestral 2	Apache 2.0	22B	~$0.30 / ~$0.90	16GB GPU at Q4	Single-GPU FIM + daily coding
DeepSeek V4-Flash	MIT	284B / 13B active	~$0.14 / —	Multi-GPU or API	High-volume budget agent runs
GLM 5.2	MIT	~743B / ~39B active	~$1.40 / ~$4.40	Multi-GPU or API	Hardest tasks among open weights
Ornith-1.0 35B	MIT	35B MoE / ~3B active	$0 (local)	24GB GPU at Q4	Privacy-first, zero API cost

Two of these — Qwen3-Coder-Next and Codestral 2 — are Apache 2.0, and the DeepSeek, GLM, and Ornith options are MIT. Every one of them lets you build a commercial product, ship it, and never think about a monthly-active-user threshold or a “Built with…” badge. That is a stronger position than a Llama-based stack, not a weaker one.

For most single-GPU developers, Qwen3-Coder-Next is the default recommendation: 70.6% on SWE-bench Verified, a 256K context window, and the cheapest credible API on the market at roughly $0.11 per million input tokens. It’s not the open-weight frontrunner anymore — it sits around seventh among open models on SWE-bench — but for the “understand the codebase → make a targeted change → run tests” work that fills most days, it’s more than enough. Our full Qwen3-Coder-Next review has the benchmark breakdown.

If you have a 16GB card and want the lightest self-hosted option, Codestral 2 at Apache 2.0 fits at Q4 and handles fill-in-the-middle well. If you need the strongest open-weight reasoning and can rent GPUs or pay API rates, GLM 5.2 is the top of this list on hard multi-file tasks. And if your priority is a model that no government order or vendor decision can switch off, a fully local Ornith-1.0 35B on a 24GB GPU costs $0 per token after hardware.

How to wire a fallback in ten minutes

You don’t need to migrate — you need a tested escape hatch. The mechanics are identical across Cline, Continue.dev, and Cursor because all three speak the OpenAI-compatible protocol:

1. Pick one permissive backend from the table and get an API key (OpenRouter is the fastest path) or run it locally through Ollama.
2. In Cline: set OPENAI_BASE_URL to the provider endpoint and OPENAI_API_KEY to your key, then select the model ID.
3. In Continue.dev: add the model to config.yaml with its apiBase and apiKey, and set defaultCompletionOptions.contextLength to match the model’s real window (don’t leave Ollama’s default context in place — it silently truncates; see our num_ctx fix).
4. In Cursor: add an OpenAI-compatible custom model under Settings → Models with the override base URL.
5. Run one real task through it — a bug fix or a small refactor — so you know it works before you need it, not during an outage.

That’s the whole drill. The point of a fallback is that it’s already configured.

The verdict

Muse Spark going closed-source is a real signal and a non-event for your coding stack in the same breath. The signal: Meta’s frontier is now proprietary, and treating any single vendor’s open-weight releases as permanent infrastructure is a mistake. The non-event: Llama 4 is still downloadable, nothing broke, and Muse Spark isn’t a coding model anyway.

The one action worth taking is the cheap one — confirm you have an Apache-2.0 or MIT coding backend tested and ready. If you want to run the local-hardware side of this, our sister site covers the GPU picks for open-weight coding models, and aifoss.dev tracks the broader open-source ecosystem. Diversify your license risk, not your panic.

FAQ

Is Muse Spark available in Cursor, Cline, or any coding tool? No. As of July 9, 2026 it’s a private-preview, API-only, general-purpose model. It’s not positioned for code and doesn’t appear in any coding tool’s model list.

Does the Muse Spark launch mean Llama 4 is being discontinued? No. Llama 4 Scout and Maverick remain downloadable on Hugging Face and llama.com. Muse Spark is a separate MSL line; nothing was pulled.

Was Llama ever truly open source? No. Llama has always shipped under the Llama Community License — source-available with a 700M-MAU cap, a “Built with Llama” attribution requirement, and EU restrictions on the multimodal models. That’s more permissive than closed API models but is not OSI open source like Apache 2.0 or MIT.

What’s the safest permissively-licensed coding backend to standardize on? For single-GPU or budget API use, Qwen3-Coder-Next (Apache 2.0). For the strongest open-weight reasoning, GLM 5.2 (MIT). Both let you build commercial products without licensing strings.

Should I stop using Llama 4 for coding? Not because of Muse Spark. But if your product is commercial and you want zero license friction, an Apache-2.0 or MIT model is a cleaner long-term base than Llama’s Community License.

Sources

• Meta’s Muse Spark is here — and it’s closed source (The Next Web)
• Introducing Muse Spark: Scaling Towards Personal Superintelligence (Meta AI)
• Meta debuts new AI model after $14 billion deal (CNBC)
• Meta Muse Image launch (TechCrunch, July 7 2026)
• Introducing Muse Image and Muse Video (Meta AI)
• Llama 4 Community License Agreement
• Qwen3-Coder-Next (Hugging Face)

---

Last verified: July 9, 2026, against Meta’s Muse Spark and Muse Image announcements, the Llama 4 Community License, and the Qwen3-Coder-Next model card. Pricing and licenses for third-party backends change frequently — confirm on each provider’s official page before you commit.