Groq Launches Meta Muse Spark Open: 816B Parameters and 350+ Tokens/s

Meta has released Muse Spark Open, an open-weight model for agentic programming, and Groq added it to GroqCloud on release day. For now, it is a limited preview. According to Groq, the model is built as a Mixture of Experts: 816B parameters in total, 42B active per token, and 256 experts. On GroqCloud it delivers more than 350 tokens per second per user with a 131,072-token context.

Architecture and specifications

About 5% of the weights (42B of 816B) work on each token. That is how MoE models are built: all parameters have to sit in memory, but only the selected experts do the computation. This is why a model of this size can, in principle, generate at high speed.

Key points from the announcement:

• 816B parameters in total, 42B active per token;
• 256 experts in the Mixture of Experts architecture;
• 131,072-token context on GroqCloud, which Groq says is enough for large codebases with dependencies and legacy code;
• input: text and images, output: text only;
• speed: 350+ tokens per second per user;
• training on real developer workflows: multi-file refactoring, debugging sessions, long-running tasks.

An agent that explains its steps

Meta designed Muse Spark Open as an agent from the start. The model plans, acts, looks at the result, and corrects course over long horizons. It can launch and coordinate subagents, browse the web, and operate a computer on desktop, in a mobile environment, and in a browser.

Before each action, the model writes a short statement of intent. The developer sees what it is about to do and why, and can step in before a change lands in the repository. For long autonomous tasks, this transparency is useful in its own right. Meta claims higher first-attempt accuracy and reliable tool calling, but Groq's material contains no concrete figures or benchmarks.

Why speed matters for agents

An agentic task is a chain of model calls, and each step waits for the previous one. Delays add up. A rough calculation: 30 calls of 2,000 tokens each make 60,000 tokens, and at 350 tokens per second that is about three minutes of pure generation. At a third of that speed, the wait would grow to nearly nine minutes. The numbers are illustrative and real ones depend on the task, but the logic is clear.

Scott Albin, head of Groq's commercial business, says agents make dozens of calls for a single task, and fast inference keeps each of them within reasonable limits. Groq reports that more than six million developers, Fortune 500 companies, and thousands of AI-native startups run on the platform. It processes trillions of tokens per week from data centers in North America, Europe, the Middle East, and APAC.

What the announcement leaves out

This is a press release from an infrastructure partner, and the speed figure comes from the vendor itself. There is no data on price per token, license terms, preview limits, or independent quality measurements. It is unknown how the 350+ tokens per second speed holds up with a fully loaded context and heavy parallel load.

How to try it

You need to request access on the groq.com/muse-spark-open page. To evaluate the model, use your own task rather than a demo:

• run a multi-file refactoring on a real repository and measure time to a finished result, not tokens per second;
• check whether your codebase with dependencies fits in 131,072 tokens;
• test calls to your own tools and the share of tasks solved on the first attempt;
• try feeding interface screenshots during debugging: the model accepts images.

If Meta and Groq have not inflated the numbers, a fast open-weight model of this class will become a serious alternative to closed agentic models. For now, that has to be verified on your own code.