Flint v1.0 vs Muse Code: A Weight File and a Terminal Agent Have Different Bills

Here is the number that makes this comparison honest before it starts. Recursive Flint v1.0 costs nothing per token and roughly 24 GB of memory. Muse Code costs between $5 and $200 a month before you send a single request, and then $4.25 per million output tokens on Meta's Standard tier. One of these is a file you own. The other is a subscription to somebody else's loop. Comparing them as though they were alternatives is the mistake most coverage makes, and it is a mistake worth making deliberately rather than by accident — because once you see the bill, the real decision is not which one is better. It is which shape your work needs.

Flint arrived on 21 October 2026 as Recursive's first model: a mixture-of-experts coder with 39.8 billion parameters in total, about 2.5 billion active per token, Apache 2.0, designed to run on a laptop. Muse Code arrived earlier — Meta shipped it as a beta on 5 August 2026 and has since taken it out of beta — and it is not a model. It is a native terminal binary that drives Meta's Muse Spark models, currently Muse Spark 1.3, with Muse Spark 1.2 still the version the CLI selects unless you tell it otherwise.

What each one actually is

A model and an agent are different products, and the difference is where the work lives.

Flint is weights. It takes text and tool calls in and gives text and tool calls out, and everything around that — the loop, the file editing, the test running, the retry logic — is supplied by whatever harness you point at it. Recursive's own serving kit uses SGLang; the ecosystem routes it through llama.cpp, Ollama, LM Studio, vLLM and Recursive's own engine. You get a fast token generator and a blank page.

Muse Code is the page filled in. It ships a main agent loop, asynchronous background agents that keep collecting context across a session, isolated Git worktrees so parallel sub-agents do not collide, and a local event log that lets a crashed session be replayed or resumed. It has slash commands for planning and review, an agent-client protocol other tools can drive it through, sandboxed shell execution with configurable approval modes, and it runs interactively or headlessly. Installation is a one-line script on macOS or Linux, with a PowerShell path on Windows. You are buying the loop, and the model inside it is not something you choose.

The cost spine, worked out

Rather than compare list prices in the abstract, take a workload. Suppose a developer's agent writes 50 million output tokens in a month — not an extreme figure for a heavy agentic workflow, and low enough to be plausible for a small team.

• Flint — licence cost $0. Output tokens unlimited. The fixed cost is hardware you either have or do not: 22.86 GB for the NVFP4 build on disk, roughly 24 GB of memory to run it, and a machine fast enough to make local inference tolerable. Recursive claims 125-plus tokens per second on an M4 Pro MacBook Pro at short context. If you already own that laptop, the marginal cost of the 50 millionth token is electricity.

• Muse Code — the monthly plan is a floor, not a ceiling, because the token billing sits on top of it. At $4.25 per million output tokens, 50 million output tokens is $212.50 in output alone before input is counted, against whichever subscription tier you needed to get access. The four plans — $5, $15, $50 and $200 a month — buy different levels of access, not unlimited usage.

• Muse Code, cheaper tier — the Contributor tier is priced at $0.10 per million input tokens and $0.20 per million output tokens, against $1.25 and $4.25 on the Standard tier. That is roughly a twenty-fold difference on output, and the reason it is cheaper is that Meta may train on your prompts and completions. That is a real trade and a legitimate one for open-source work. For a proprietary codebase it is a policy decision, not a discount, and it is worth reading the current terms rather than trusting a summary — including this one.

• Flint, hidden cost — the machine. A 24 GB working set on a laptop is fine; on a desktop with a 24 GB card it is tight once you account for the rest of the system. And local throughput at long context is not what the headline number suggests: independent testing reported roughly 110 tokens per second at short prompts falling to about 9 tokens per second around 115,000 tokens of context. An agent that reads a large repository before writing anything will spend most of its time in the slow regime.

Put those side by side and the cost comparison is not close on a per-token basis, and not close in the other direction on a total-capability basis. That is the whole point.

Privacy is where the gap is widest

Flint runs offline. Not "we do not log your prompts" offline — actually disconnected, on your hardware, with the weights on your disk. For a codebase that cannot leave a network, that is not a feature among features; it is the reason the model exists in this comparison.

Muse Code is a cloud agent. It runs commands against a repository, and that means the things it reads travel. The contributory pricing tier makes the data relationship explicit rather than implicit, which is arguably more honest than a policy nobody reads, but it does not change the direction of travel. If your constraint is "source code never leaves the building," the decision has already been made and the benchmark table is irrelevant.

Who runs the loop, and why that decides more than the model

The most underrated difference is that with Flint you are responsible for the agent. A 39.8B model that activates 2.5B parameters per token is a capable token generator, but Recursive says plainly that it needs more guidance than the large paid coding assistants and recommends breaking complex jobs into smaller steps. That guidance has to come from somewhere — a harness, a prompt template, your own glue. If you do not have that, you do not have an agent.

Muse Code has already made those decisions for you, and that is what the subscription buys. The trade is that you inherit Meta's opinions about how a coding session should run, and you cannot swap the model underneath.

There is a middle path that neither vendor advertises, and it is the one most teams converge on: keep the local model for the work that must not leave the machine, and keep a hosted endpoint for the work that needs more capability than a 2.5B-active model can supply. That is the case where routing stops being infrastructure trivia and starts being the architecture. If the escalation path is one OpenAI-compatible endpoint in front of 200-plus hosted models at provider list price with no markup added, then adding capability later does not mean adding a second contract and a second SDK — and a failover chain means a request that times out against one provider can complete against another without your agent noticing.

Which one to pick

One number deserves to sit between the cost argument and the decision, with a clear label on it. Meta's own launch chart places Muse Spark 1.2 at 82.9% on Terminal-Bench 2.1, second on its own panel. Flint's vendor-reported Terminal-Bench 2.1 score is 54.9%. Those two figures were produced by different labs, on different harnesses, with different rules about whether an agent may search the web — so the 28-point gap is not a measurement of anything you can hold in your hand. It is a strong hint, though, that the capability ceiling of a 2.5B-active local model and a frontier-adjacent hosted one are not in the same place. If your work routinely requires the harder end of agentic coding, the local option is not a substitute however good the price looks.

• Choose Flint if the code cannot leave your machine, if your agent tasks are short and well-scoped, if you already have a harness you like, or if you want to stop paying per token for a workload that is going to keep growing. Budget for the long-context throughput and plan your agent around it.

• Choose Muse Code if you want a working terminal agent on day one, if your tasks run for hours and benefit from background agents and resumable sessions, if your work is open enough that the contributor tier is acceptable, and if a monthly bill that scales with usage is easier to justify than hardware.

• Choose both if you are a team with a mixed codebase. The split is usually obvious once you ask which repositories are allowed to leave.

What you should not do is treat this as a benchmark question. Flint's published scores — 74.2 on SWE-bench Verified, 89.7 on SWE-bench Pro v2, 54.9 on Terminal-Bench 2.1 — are vendor-reported and have not been independently reproduced. Muse Code's model family has its own vendor-produced charts. Neither set of numbers tells you what happens when your agent meets your monorepo on a Tuesday. The cost structure and the data path do, and they are knowable before you spend anything.