Muse Code Pricing 2026: Plans, Real Limits, Wonder Full

What every Muse Code plan really costs, how the five-hour and weekly limits behave, what Contributor mode trades away, and when the $50 Power plan for Muse Wonder Full pays for itself

Meta now sells a frontier coding agent for $5 a month, and its strongest model starts at $50. Since October 12, 2026, the Muse Code page lists four plans: Everyday at $5, High at $15, Power at $50 and Maximum at $200, with usage described as "10-50 prompts every 5 hours" on the cheapest plan and as multiples of that on the others - Meta. Muse Wonder Full, the stronger of Meta's two new models, appears only on Power and Maximum and is not sold through the API at all, while the standard Muse Wonder costs $4 per million input tokens and $20 per million output tokens for anyone with an API key - Meta Model API docs. TechCrunch called Wonder the company's "first attempt at a frontier model" - TechCrunch, the launch post passed 660 points and 380 comments on Hacker News within days - Hacker News, and by October 16 Google was completing "muse code" with "subscription", "pricing" and "plans" before anything else.

The problem is that none of those numbers tells you what you actually get. A "prompt" in a multi-agent tool can be one small edit or an hour of work by a dozen agents. Meta mentions a weekly reset but publishes no weekly cap. Every subscription starts in Contributor mode, where Meta trains on your code in exchange for more usage, and Meta's terms say you must not send confidential code there; independent measurement suggests that switching it off costs you about eleven-twelfths of your allowance. The first day's usage reports were distorted by a metering bug that Meta fixed that evening. And the plans have changed shape several times since August, so most of what was written about Muse Code pricing before October 12 is out of date.

This guide answers those questions with evidence rather than the rate card. It reconstructs how the plans changed using Meta's own announcements and archived copies of its pricing page, explains how usage is metered (including the launch-day metering bug Meta fixed hours after release), works out what a coding task costs at API prices using Artificial Analysis data, and sets Muse Code against Claude Code, Codex, Cursor, GitHub Copilot and Google's plans. It ends with a plan-by-plan decision guide. No technical background is assumed; where a section gets technical, the plain version comes first. If you want the model-level story (benchmarks, safety, the Muse app), our Muse Wonder guide covers it in depth; this piece is about the bill.

Contents

1. Muse Code pricing on one page
2. How the plans got here: three plans in August, four in October
3. What a prompt buys: five-hour windows, the weekly cap and metering
4. Contributor mode: the discount you pay for with your code
5. Muse Wonder Full: what the $50 actually unlocks
6. Pay-as-you-go: the API key route and the cost of a task
7. Subscription or API: the break-even math
8. Muse Code vs Claude Code, Codex, Cursor and Copilot on price
9. How to make a Muse Code plan last longer
10. Where Muse Code pricing fails, and the risks
11. Which plan to choose
12. The outlook for Muse Code pricing
13. The bottom line

Every way to pay for Muse Code, scored

Before the detail, here is how the six realistic ways to pay for Muse Code compare. Four are the subscription plans; two are pay-as-you-go routes that use a Meta Model API key instead, one with the standard Muse Wonder and one with the discounted Contributor version of Muse Spark 1.3. Each option is scored on the same five criteria from Meta's documentation, Meta's legal terms, independent benchmark data from Artificial Analysis and hands-on reports from developers, and each cell shows the score with the fact behind it. A seventh route, Muse Spark Open through a third-party host, sits outside Meta's billing altogether and is covered in section 6.4.

The ranking answers a practical question: if you want to use Meta's coding agent this month, which way of paying gives you the most useful work per dollar with the fewest surprises? It is not a ranking of Meta against other vendors (section 8 does that). Scores run from 0 to 10, the final score is the weighted average, and the table is sorted from highest to lowest.

How the criteria work. Model access (25%) scores the strongest model each option unlocks, anchored to the Artificial Analysis Coding Agent Index, where Muse Code with Wonder Full scores 68.0, with Wonder 63.5 and with Spark 1.3 at xhigh effort 48.3 - Artificial Analysis. Cost per unit of work (30%) uses Meta's own plan multiples for subscriptions and Artificial Analysis's measured cost per coding task for the API routes; it carries the most weight because price is why people search this topic. Headroom (15%) scores how much work fits before you are stopped and what happens then. Data terms (15%) score what Meta may do with your code under its terms. Predictability (15%) scores how well you can know the bill in advance. Final scores are weighted averages rounded half up.

Read the table as a default, not a verdict. Power wins because it is the cheapest per unit and the only affordable door to Wonder Full, but it scores only 5 on data terms because every subscription starts by training on your code. The Standard API route is the opposite: worst on cost per task, best on data, with no windows to wait out. Everyday ranks last not because $5 is a bad price but because the allowance is too small for real work; treat it as a trial. One assumption sits under every subscription row: the cost scores assume you keep Contributor mode on, as Meta's default does. Switch it off and each plan's allowance falls to roughly a twelfth (section 4.3), which would drop High and Everyday below the Standard API route. The sections below explain where each number comes from, starting with the plans themselves.

1. Muse Code pricing on one page

Muse Code is Meta's coding agent for the terminal and CI: you run it inside a project folder, describe a task, and it plans, edits files and runs commands, "with approvals and an OS sandbox on from the first run" - Meta. It runs Meta's own models, it is "multi-agent by default" with workers in parallel and reviewers in the background, and it installs with a one-line script on macOS and Windows (Meta's documentation also covers Linux). You can pay for it in two ways: a flat monthly subscription, or pay-as-you-go billing per token through a Meta Model API key.

The subscription is the headline product, and its structure is simple to state. There are four plans, each defined as a multiple of the cheapest one, and each renews monthly on the date you first subscribed. What makes the structure unusual is that the unit itself is not fixed: the Everyday allowance is a range ("10-50 prompts every 5 hours, including image and video uploads"), so every other plan is a multiple of a range. Meta adds that "subscription benefits and availability may vary by region" and that the benefits available to you are shown during onboarding - Meta.

Source: Meta's Muse Code product page, checked October 16, 2026. Price per unit is our arithmetic: monthly price divided by the usage multiple.

The table shows two things the plan cards do not say outright. First, the volume discount stops at Power: High is 40% cheaper per unit than Everyday and Power is 50% cheaper, but Maximum costs exactly what Power costs per unit. Most subscription ladders reward the biggest buyer; Meta's treats Maximum as an overflow plan for people who run out of Power, not a better deal. Second, Wonder Full is a plan feature, not a separate product: there is no Wonder Full add-on, so the cheapest way to touch it is the $50 plan.

The chart makes the shape of the ladder plain: a steep drop from $5 to $3 per unit, a smaller one to $2.50, then a flat line. In practice that means the move from High to Power is the best-value upgrade on the ladder (four times the usage for 3.3 times the price, plus Wonder Full), while the move from Power to Maximum buys capacity only.

1.1 The pay-as-you-go side of the price list

The second way to pay is per token. Muse Code accepts a Meta Model API key, and any request made with a key other than the one your subscription connects during onboarding "will be billed through pay-as-you-go" - Meta help center. The API prices are the same whether you call the models from Muse Code, from your own code, or from another agent such as Claude Code or Codex. The token rates below come from Meta's pricing page, which also notes there is no long-context premium and that web search grounding costs $2.50 per 1,000 queries on top of tokens.

Source: Meta's pricing and rate limits page, checked October 16, 2026. Muse Wonder is still labeled a preview model in Meta's model documentation.

Three practical details round out the price list. Meta bills pay-as-you-go usage "whenever your current balance reaches your payment threshold amount", and charges any remaining balance on the first of each month - Meta. Subscriptions are billed monthly only; Meta's documentation describes no annual option, which matters when comparing against Anthropic's $17-a-month annual Pro price. And prices are quoted in US dollars before tax: Meta's subscription terms make the buyer responsible for VAT and sales tax - Meta Subscription Terms.

A naming trap to avoid. Meta's consumer agent app, Muse, also has paid plans called Power and Maximum, at $20 and $100 a month - TechCrunch. They are a different product with different allowances. A Muse app subscription does not include Muse Code, and a Muse Code Power plan is not the $20 Muse Power plan.

Why this matters: the four prices look like a simple ladder, but the unit underneath them is a range, the discount stops at Power, and the strongest model is a plan feature rather than something you can buy by itself. How to apply this: compare plans by price per unit, not by monthly price, and decide first whether you need Wonder Full, because that single decision puts you on Power or above.

2. How the plans got here: three plans in August, four in October

Muse Code pricing is ten weeks old and has already changed shape three times, which is the strongest reason to distrust any price list you did not check this week. Reconstructing the history also tells you something about where Meta is heading, so it is worth doing carefully. We pieced it together from Meta's own announcements, contemporary press coverage and archived copies of the Muse Code page held by the Internet Archive.

Meta released Muse Code in beta on August 5, 2026, as "a terminal coding agent powered by Muse Spark 1.2" - Meta. Subscriptions did not exist yet, so the only way to pay was per token, and there were two token prices: Standard at $1.25 per million input tokens and $4.25 per million output, and a Contributor tier at $0.10 and $0.20 for users who let Meta train on their prompts and completions, a trade-off that several engineering leaders said would rule it out for proprietary code - The New Stack. The pricing story at launch was "aggressively cheap tokens for your data", and the Contributor discount was the hook.

2.1 August 31: the first subscriptions

On August 31, Meta took Muse Code out of beta and introduced subscriptions, describing them as "granting more affordable Meta Model API usage than pay-as-you-go pricing" - Meta for Developers. There were three plans, and the multiples were smaller than today's: High offered 3x the Everyday allowance and Power 10x - Subscription Insider. Meta's own announcement graphic shows the original offer, including that every plan then ran on Muse Spark 1.2.

The graphic is worth studying because of what changed next. The prices on it ($5, $15, $50) are the same as today's, and the base unit ("10-50 requests every 5 hours") is worded almost identically. Everything else moved: the multiples, the models behind them, and the number of plans.

2.2 September: the multiples double

By September 21, the archived Muse Code page already listed High at 5x and Power at 20x the Everyday allowance, at unchanged prices - Internet Archive. A later archived copy shows the same three plans and the same multiples still in place on October 10. Earlier in September the model behind the plans had changed too: Muse Spark 1.3 went live on September 2, at the same token prices as 1.2 - OpenRouter. We could not find a Meta announcement of the multiple change itself, so the exact date is unknown, but on paper High and Power customers received 67% and 100% more usage for the same money.

2.3 October 12: Wonder, Wonder Full and the $200 plan

On October 12, alongside the Muse Wonder launch, the page gained a fourth plan, Maximum at $200 with 80x the Everyday allowance, and the model list split: Muse Wonder on every plan, Muse Wonder Full only on Power and Maximum. Meta's launch post says "Muse Wonder Full is available today for Muse Code subscribers" - Meta. CNBC confirmed that it sits behind the $50 and $200 plans - CNBC. Meta's model designation policy was updated the same day to list Muse Wonder and Muse Wonder Full as Standard models - Meta. That evening brought a fifth change that is easy to miss: Meta fixed a metering fault that had been draining Wonder and Wonder Full allowances too fast and reset every subscriber's usage (section 3.2 covers it). Three days later, on October 15, Meta released the open weights of Muse Spark Open, which created a route to Spark-class models outside Meta's billing entirely (section 6.4).

From first principles, the history reads as a pricing team discovering its own costs in public. A subscription is a bet that the average subscriber uses less than they pay for. When Meta's plans ran only on Muse Spark, a cheap model at $1.25 and $4.25 per million tokens, Meta could afford to double the multiples within weeks. Muse Wonder costs 3.2x Spark's input price and 4.7x its output price on the API, so the same words ("10-50 prompts") can now cost Meta several times more to serve when the prompt runs on Wonder. The new Maximum plan, priced at the same unit rate as Power, is what a provider adds when it wants to keep its heaviest users without giving them a discount.

Why this matters: the base unit has stayed the same in words while the models behind it, and so the cost of a prompt, have changed. How to apply this: treat any Muse Code allowance figure older than October 12 as historical, check the plan page on the day you buy, and expect further changes; Meta's subscription terms let it modify benefits, with at least 30 days' notice for a price increase - Meta Subscription Terms.

3. What a prompt buys: five-hour windows, the weekly cap and metering

The most important question about any coding subscription is how much work fits inside it, and it is the one Meta answers least directly. The plan pages express everything in prompts: "Send 10-50 prompts every 5 hours" on Everyday, and multiples of that above. The range itself is the honest part of the sentence. A prompt in Muse Code is a request that can start a single quick edit or a long multi-agent run, so the cost of a prompt varies by orders of magnitude depending on what it sets in motion.

To understand the meter, it helps to think about what Meta actually spends when you press Enter. It pays for the tokens every model call reads and writes, and in Muse Code one prompt fans out into many calls: the main agent, its subagents, a team of background observers and, for large tasks, a workflow of child agents. So the real unit of consumption is compute, and "prompts" is a friendly translation of it. The rest of this section shows what the meter looks like in practice, using Meta's documentation, its changelog and two independent sets of readings.

3.1 The two meters: five hours and one week

Meta's plan pages mention only the five-hour window, but Muse Code tracks a second one. Its own changelog for version 1.4.0 says the serve protocol "can now report your remaining subscription usage on demand", returning "the last-seen 5-hour and weekly windows without spending a prompt" - Meta changelog. In other words, there is a weekly cap, it is metered separately, and Meta does not publish its size. Meta's own Wonder announcement for developers confirms the structure in passing, describing the new Maximum plan as bringing "an 80x limit over the Everyday Usage plan and the same five-hour and weekly resets" - Meta for Developers. Meta's terms add that the allowance "expires at the end of each period and does not roll over or accumulate" - Meta Model API terms.

Users see both meters. On launch day, one developer on the $5 Everyday plan posted the usage panel after three small requests (checking installed software versions and running a blog-analytics skill): 52% of the current window used and 17% of the week, with the weekly reset set for October 18 at 8:00 PM. Their verdict was blunt: "The usage limits on their basic $5 code plan to try things out are ludicrously low?" - Hacker News.

The higher plans told the same story that afternoon. A subscriber on the $15 plan reported that "two somewhat small prompts with Muse Wonder Max-contributor used 4% of my weekly quota", and quickly went back to Spark - Hacker News. At that rate the week would hold about fifty such prompts, far below what "5x of 10-50 every five hours" suggests on paper. A tester on the $50 Power plan called the limits "okay-ish" but "not too generous" after a session of real development work - Hacker News. These are individual reports rather than measurements, and, as the next part explains, they share a problem that matters more than their sample size.

3.2 The launch-day metering bug

Every one of those reports was posted between 18:05 and 20:49 UTC on October 12. At 22:31 UTC the same day, Meta's chief AI officer Alexandr Wang posted that Meta had "identified and fixed the issue that was causing the unusually fast quota usage for muse wonder and muse wonder full", that users "will now see much lower usage against your limits", and that Muse Code usage had been reset - Alexandr Wang on X. The post passed 350,000 views within days. Not everyone was convinced straight away: one of the first replies under it was a usage screenshot captioned "Not fixed. This is after reset." Reports of worse experiences circulated too, including a reviewer who hit rate-limit errors within minutes of subscribing to the $50 plan and again after upgrading to $200 - MindStudio.

The best-documented case on video is Matthew Berman's launch-day review, which passed 120,000 views within four days. After his hands-on tests he turns to access and pricing: the $15 plan did not give him Wonder Full, the $50 plan ran into limits within minutes, and the $200 plan did not hold out for long either. It is worth watching as a record of what the meter felt like before the fix, not as a description of the plans today.

So the most-quoted numbers about Muse Code limits describe a meter that Meta itself says was broken. That does not make them worthless, but it changes how to read them. By Wang's description, the fault affected Muse Wonder and Wonder Full, so the Wonder readings above are upper bounds on what those models cost against your plan today, while readings on Spark are presumably unaffected. Anyone who formed a view of the plans in the first afternoon (and many of the launch reviews did) formed it on inflated numbers.

There is a more general lesson in the episode, and it is the most important idea in this section. A usage-based subscription has two prices: the one on the plan card, and the meter that converts your work into a percentage. The first is public and stable; the second is private, changes without notice and, as October 12 showed, can be wrong. Meta's response (a fix and a full reset within hours) was about as good as such a failure allows, but no buyer could have detected the error from the inside. The only defense is the one section 9 describes: measure your own consumption with /usage on a few known tasks, and re-measure after every release.

3.3 Independent readings on the Power plan

The most careful public measurements come from Kingy AI, which ran matched jobs with Muse Wonder and Muse Wonder Full on a Power subscription in Standard mode, in Muse Code 1.4.7, and recorded how much each accepted job moved the two meters - Kingy AI. Their jobs were small to medium Python projects (a pagination utility, an invoice reconciliation tool and a three-stage task tracker), run at medium reasoning effort, and every delivered program passed its acceptance tests. Kingy dates the work to October 12, Pacific time, and its article first went online at 18:21 UTC, about four hours before Wang's fix, so these readings may also include the faulty metering.

Source: Kingy AI's coordinated allowance readings, October 12, 2026 (Pacific). Meters display whole percentage points, so small jobs can round to zero.

Two patterns stand out, and they survive the bug differently. First, Wonder Full used two to three times more of the five-hour meter than Wonder for the same accepted job, and took longer. Both models were affected by the fault, so the absolute numbers are probably too high, and whether the gap between them holds after the fix is unknown. Second, across both independent sources the weekly meter moved about one-third as fast as the five-hour meter: 15 to 5 and 6 to 2 on Kingy's Power account, and 52 to 17 on the Everyday user's panel.

That second pattern is the more durable one, for a structural reason. Both meters count the same consumption, so a bug that inflates consumption should move both by the same factor; the ratio between them reflects the relative size of the two caps, not the size of the bug. If that holds, then a week holds roughly three full five-hour windows. A developer who maxes out three windows in a week is then done until the weekly reset, however many windows remain.

A third measurement, taken on October 3 on Spark, nine days before Wonder existed and so out of reach of a Wonder metering bug, points the same way. On a $15 High plan in Standard mode, Paweł Huryn's logged run saw the five-hour meter rise 22 points while the weekly meter rose 6, and he valued a full five-hour window at about $10 of Spark usage at API prices, against roughly $32 for a whole week - phuryn/experiments. That is between three and four windows per week, from a different person, a different plan and a different week. His own conclusion is blunt: in Standard mode, "the 5-hour window is the real limit", because a single busy session reaches it quickly. The weekly cap then decides how many such sessions you get, which is three or four. Three independent sources agreeing on the ratio is much better evidence than any one of them, and it is the most useful planning number in this guide.

3.4 What that implies for each plan

Putting Meta's advertised range next to the observed ratio gives a rough picture of each plan's ceiling. The table below is an estimate, not a measurement: the weekly column multiplies the advertised five-hour range by three, and the real number depends on which model you use, how hard it thinks and how many agents each prompt starts. It is most useful for comparing plans with each other.

Estimates are ours, built from Meta's advertised allowance and the meter ratio observed in the two sources above. Agentic prompts in practice land toward the bottom of each range.

The important caveat is in the last line. The only detailed public readings, all taken before the fix, landed near or below the bottom of Meta's range: the Everyday user's three prompts used more than half a window, which implies about six prompts per window, not ten. Some of that gap was the bug. Some of it is structural, because "prompt" counts imply something conversational, while an agent that reads a repository, runs tests and starts helpers consumes like a dozen conversations. As of October 16 no one has published post-fix readings with the same care, so treat the bottom of each range as the realistic planning figure for agentic work and the top as what light chat-style use can reach.

3.5 What makes one prompt expensive

Several Muse Code defaults multiply the compute behind a single prompt, and knowing them is the difference between a plan that lasts all week and one that runs dry on Tuesday. Muse Code runs four background observer agents by default, each watching one axis of quality and proposing advisories to the main agent - Meta. Its workflow engine can call up to 1,000 child tasks over a workflow's life, with a local limit on simultaneous children that is capped at 16, and Meta's documentation warns that a workflow adds "time and token usage" - Meta. At max reasoning effort, new sessions "now allow 64 concurrent agents including the main agent" - Meta changelog.

None of this is waste: the observers catch mistakes, workflows finish large jobs faster, and parallel agents are a large part of why Muse Code scores well on long tasks. But each of those agents reads context and writes tokens, and all of it lands on the same two meters. A subscription that feels generous for a single agent answering questions can feel tight for a dozen agents refactoring a repository, even though both count as one prompt. The levers below are the ones that most change what a prompt costs.

• Reasoning effort: Muse Code offers eight levels from none to ultra, with high as the documented default
• Model choice: Wonder Full drew two to three times Wonder's allowance in Kingy's tests
• Agent fan-out: subagents, observers and workflows each make their own model calls
• Context size: large repositories and long sessions are re-read on every call
• Multimodal input: image and video uploads count toward the same allowance

These five levers explain why two prompts that look identical in your terminal can cost very different amounts. Effort and model choice set the price of each model call, fan-out sets how many calls happen, and context sets how many tokens each call reads. Independent testers also found that some Muse Code builds started at the most expensive settings when nothing was saved: AIWiz reported version 1.4.2 starting on the Contributor model at max reasoning effort, even though the configuration docs name high as the default - AIWiz. Checking your effort level before a long session is the cheapest saving available.

3.6 What happens at the limit

When you hit a limit, Meta offers two options: "upgrade to the next plan, or wait until your limit refreshes", and on Maximum "you must wait for your limit to refresh" - Meta. Upgrades take effect immediately with a prorated charge; downgrades take effect at the next billing cycle. There is no paid top-up for a Muse Code subscription: Meta's terms state that subscription usage "does not qualify as Additional AI Usage", the dollar-denominated top-up that some other Meta subscriptions offer - Meta Model API terms. The only way to keep working through a limit without upgrading is to switch Muse Code to a pay-as-you-go API key, which works for Wonder and Spark but never for Wonder Full.

Why this matters: the five-hour number Meta advertises is not your real ceiling; the undocumented weekly meter is, and the defaults that make Muse Code capable (many agents, high effort) are the same ones that drain it. How to apply this: run /usage and /status often in your first week to learn your own consumption, plan heavy sessions so they do not stack in two or three days, and keep a pay-as-you-go key configured as an overflow route for deadline work.

4. Contributor mode: the discount you pay for with your code

Every Muse Code subscription starts in Contributor mode. Meta's wording is direct: "In Contributor mode, you get more usage from your plan in exchange for letting Meta use your content to train future Meta models", where content means "the prompts, code, files, and context you send, plus the model responses you get back" - Meta. You can switch it off at any time in /settings, and from then on your future content is not used for training. Muse Wonder and Muse Wonder Full both work in either mode on the plans that include them.

What the plan pages do not spell out is the other side of the trade. Meta's help center confirms that "turning Contributor mode off changes how much usage you get from your plan", while not saying by how much - Meta help center. So the advertised multiples are best read as Contributor-mode allowances, and a developer who protects their code gets a smaller amount that Meta does not publish. Independent measurements, covered in section 4.3, put the difference at roughly twelvefold. That makes Contributor mode the largest hidden price component in Muse Code: most of what makes the subscriptions look generous is paid for in data.

4.1 What the terms actually say

The legal terms behind Contributor mode are stricter than the product pages suggest, and anyone using Muse Code at work should read them. Under Meta's Model API terms, a subscription counts as "Contributor Services" by default "regardless of which Meta Model you select", and switching to Standard "would apply prospectively only": code you sent before switching stays usable for training - Meta Model API terms. The same terms say models trained on your content "may produce outputs or take actions (including for third parties) that are similar or identical to your Content".

That last clause is the one that turns a privacy question into a business one. Meta says it takes steps to disassociate Contributor content from your account before training, but a model that has learned from your code can still reproduce something close to it for another user. For a hobby project that hardly matters. For proprietary algorithms, unreleased features or a client's codebase, it is a leak that no setting can recall once the data is in a training set. The clauses below set out what that means in practice.

• No confidential code: "If you intend, or are required (including by contract), to keep information such as software code confidential, you must not submit that information to the Contributor Services"
• No going back: switching off applies to future content only
• Mixed content: Standard-mode content sent again in a Contributor request becomes Contributor content
• No IP indemnity: Meta's intellectual-property indemnity covers Standard Services, not Contributor use
• No ZDR: per Meta's help center, Contributor mode "isn't available to accounts with Zero Data Retention"

Read together, these clauses make Contributor mode a poor fit for almost any professional use. The confidentiality clause alone excludes client work, employer code and anything under an NDA, because those are exactly the things you are "required (including by contract)" to keep confidential. The mixed-content clause is the subtle one: if you work in Standard mode, then flip Contributor on for a cheaper session in the same repository, everything you paste into that session is now training data, including what you wrote earlier. And losing the IP indemnity means that if a model output infringes someone's copyright, Meta's promise to defend you does not apply.

4.2 What the default looks like on screen

Independent testers found the Contributor default in practice, not just on paper. AIWiz installed Muse Code twice, a week apart, and both times it started on the Contributor version of Muse Spark, with a notice that content "may be used for product improvement" - AIWiz. Their screenshot from version 1.4.2 shows how little stands between a first session and a training dataset.

The status line at the bottom carries three defaults at once: the Contributor model, max reasoning effort and an Auto-review approval mode. Meta's changelog confirms the design intent: "Contributor mode is now on by default for subscribers", and the notice shows "before any request is sent in contributor mode" - Meta changelog. The notice is real, but a notice and a default are not the same as a choice.

The same changelog holds a detail that matters to anyone who has already switched the setting off. Version 1.4.8 lists, among its fixes, that "Turning off Contributor mode in settings now fully opts out, including background requests". Read plainly, builds before 1.4.8 could still send some background requests in Contributor mode after you had turned it off. The same release also makes a Contributor-mode session switch to the cheaper -contributor model as soon as one appears in the served catalog, mid-session included. Neither note is a scandal, since both are fixes, but together they show that the switch is enforced by client code that has had bugs. If the setting carries legal weight for you, update to the latest build (1.4.9 at the time of writing), check that the status line no longer shows a -contributor model, and treat older installs on shared machines as suspect.

4.3 How much is your code worth to Meta?

From first principles, Contributor mode is the most Meta-shaped part of the pricing. Meta's core business has always been to exchange a service for data, and coding sessions are unusually valuable data: they contain a goal, a codebase, the model's attempts, test results and a human's corrections, which is exactly the long-horizon trajectory that reinforcement learning for agents needs. The API price list puts a number on that value. Muse Spark 1.3 Contributor costs 12.5x less for input, 21x less for output and 75x less for cached input than Standard Spark, with the same model weights. Meta is willing to forgo more than 90% of its token revenue in exchange for the data.

The subscription version of the trade is less transparent, because Meta does not publish the Contributor bonus. The best public measurement of it comes from Paweł Huryn, author of The Product Compass newsletter, who on October 3 deliberately burned part of a $15 High plan's weekly allowance in each mode, logged every model call through Muse Code's own usage protocol, and priced the calls at Meta's API list prices - phuryn/experiments. In Standard mode, one percent of the weekly meter bought about $0.32 of Muse Spark 1.3 at API prices, so a month of the $15 plan was worth roughly $140 of API usage, 9.3 times its price. In Contributor mode, the same percent bought about 12 times more tokens, worth roughly 114 times the plan price when valued at Standard API rates (with a wide margin of plus or minus 33, because the run mixed workloads).

Those two numbers are the exchange rate this guide has been looking for. A developer who keeps Contributor mode on gets, by this measurement, about twelve times the tokens of one who turns it off, on the same plan and the same money. Put the other way round, protecting your code on Muse Code costs roughly eleven-twelfths of your allowance. That explains why one subscriber on the $15 plan wrote that its value with "Muse Spark 1.3 Max-contributor beats everything else by a long shot" - Hacker News, and why so many first impressions of Muse Code's generosity do not survive switching the setting off. Two caveats keep the number honest: it was measured on Spark before Wonder existed and before the October 12 metering fix, and it comes from one careful run rather than a panel. For open-source work, side projects and learning, the trade is a fair deal knowingly made. For anything you are obliged to protect, it is not a deal at all, and Meta's own terms say so.

The strongest sign that this trade is a real price, not a Meta quirk, is that a competitor has now copied it under the same name. Google's API documentation describes a Gemini API Contributor Tier that gives "up to 50% off token costs for select models in exchange for permission to use data from those models", and the supported models include its new flagship, Gemini 4 Argon - Google. Because that data trains Google's models, the same page tells developers: "please don't submit sensitive or personal information". The two offers differ in size: Google discounts its flagship by half, while Meta discounts Spark by more than 90% and offers no Contributor price for Wonder on the API at all. But the logic is identical, and it is a logic worth understanding before you buy any coding plan: when two frontier labs price their tokens in both money and data, data has become a currency, and the user who pays in it should know its exchange rate.

Why this matters: the advertised allowance assumes you donate your code; protecting it costs usage, and the default protects nothing. How to apply this: decide the mode before your first session, not after; turn Contributor off in /settings for any repository you do not own outright, keep a separate machine or account for public projects if you want the bonus there, and if you need contractual guarantees, use the Standard API route (section 6), which never trains and qualifies for Meta's IP indemnity.

5. Muse Wonder Full: what the $50 actually unlocks

Muse Wonder Full is the reason the Power plan exists in its current form, and the reason many developers are reading about Muse Code pricing at all. It is Meta's higher-capability variant of Muse Wonder, it tops several rows of Meta's launch table, and it is available only inside Muse Code on the Power and Maximum plans. Meta's documentation is explicit that it is a separate model: Wonder Full "is available only in Muse Code with a subscription, so setting reasoning effort to max on Muse Wonder doesn't select it" - Meta. Its model page lists an ID, muse-wonder-full-1.0, with no token price.

Meta's official launch video is the quickest way to hear how the company pitches the pair. It runs about two and a half minutes, and its description states the access split this guide is about in one line: Wonder is available "via the Meta Model API and Muse Code", while Wonder Full "is available today for Muse Code subscribers". Meta's research post adds the two ideas it builds the models around, Active Memory and Active Focus, which explain why Meta wants its strongest variant running inside its own agent rather than someone else's - Meta AI Research.

Whether $50 is worth it depends on how much better Full is than the Wonder you already get on the $5 and $15 plans. The answer varies sharply by type of work, which is the most useful thing to know before upgrading.

5.1 Where Full is much better, and where it is not

Meta's own table, which compares both variants at max effort, shows a mixed picture - Meta. On the Artificial Analysis Intelligence Index, Full scores 56 against Wonder's 52. On terminal coding (Terminal-Bench 4.0, as run by Artificial Analysis) the gap is 57.1 to 52.0, on SWE-Marathon (very long engineering projects, with Full run at xhigh effort) 57.5 to 53.1, and on ProgramBench (rebuilding a program from scratch) 59.0 to 50.0. But on DeepSWE, a benchmark of long-horizon software tasks across 91 repositories, the two are almost level.

The chart shows 79.0% for Full and 78.8% for Wonder, a gap of 0.2 points, while both lead Claude Opus 5.5 and GPT-6 Astra by about five points. Meta's model card notes that the DeepSWE results for both Muse models and for Claude Opus 5.5 come from Datacurve's third-party runs, while GPT-6 Astra's is OpenAI's own reported figure, and that the benchmark spans 113 tasks across 91 repositories - Meta model card. In plain terms: on the kind of task DeepSWE measures (understand a repository, make a correct multi-file change), the $5 plan's Wonder is already about as good as the $50 plan's Full.

Read the same table across rather than down, and Full's position is less dominant than much of the launch coverage suggested. Claude Opus 5.5 scores higher on Terminal-Bench 4.0 (59.6 against 57.1), on ProgramBench (70.5 against 59.0) and on the Artificial Analysis Intelligence Index (58 against 56), and GPT-6 Astra also edges Full on Terminal-Bench (59.1). Where Full does lead is the long-horizon and professional rows: SWE-Marathon (57.5 against Opus's 46.3), DeepSWE, and the Harvey legal benchmark, where it scores 13.1 against 4.2 for Opus. Meta's own chart of the Intelligence Index, reproduced below, shows the full field and, just as usefully for a pricing guide, how quickly Meta's models have climbed.

The arrows tell the pricing story better than any plan card. In a few months Meta's best model went from 31 to 56 on the index: Muse Spark, Spark 1.1 at 34, Spark 1.2 at 40, Spark 1.3 at 48, then Wonder at 52 and Wonder Full at 56. Each step is a larger or longer-thinking model, so each step makes the average Muse Code prompt more expensive for Meta to serve. A plan that promises "10-50 prompts every 5 hours" at a fixed price has to absorb that drift somewhere, and in October Meta absorbed it by putting the newest step behind the $50 plan. Expect the same move the next time the arrow climbs.

Artificial Analysis's own runs of Muse Code tell a similar story, and they are the fairest comparison because both variants ran in the same harness with the same settings. The chart below shows its three coding benchmarks and the combined index for Muse Code with each variant at max effort.

Almost the entire gap between the two variants comes from one benchmark. On repository bug-fixing (DeepSWE) and codebase question-answering (SWE-Atlas QnA), Full is about one point ahead; on Terminal-Bench 4.0, which tests harder tasks completed in a terminal environment, it is 11.6 points ahead (59.1% against 47.5%). That lifts Muse Code with Full to 68.0 on the Artificial Analysis Coding Agent Index, within half a point of the leader, Claude Code running Claude Sonnet 5.5 at max effort (68.4), while Muse Code with Wonder sits at 63.5 - Artificial Analysis. Full also took longer, about 29 minutes per task against 22 for Wonder.

5.2 Full costs more allowance, not just more money

Section 3 showed that Wonder Full consumed two to three times more of the five-hour meter than Wonder for the same job in Kingy AI's tests. Artificial Analysis's token counts add a revealing detail: in its coding runs, Full and Wonder read almost the same number of tokens per task (14.92 million and 14.93 million) and wrote about the same (85,000 and 90,000). If the work in tokens is the same but the meter moves two to three times faster, the most likely explanation is that Meta weights Wonder Full's tokens more heavily, presumably because a larger model costs more to serve. That is our inference, not something Meta states, but it fits both data sources.

The practical consequence is that upgrading to Power for Full does not mean using Full for everything. Kingy AI found that on small and medium utilities "regular Wonder completed the same three kinds of Python projects as Wonder Full", with every delivery passing its acceptance checks, and concluded that "our results support starting with regular Wonder". In a larger-repository follow-up, Muse Code with Full, Claude Code with Opus 5.5 and Codex with GPT-6.1 Sol all completed four Flask jobs, with summed run times of 26:39, 8:53 and 19:05 respectively - Kingy AI.

5.3 The real price of Wonder Full

The cleanest way to price Wonder Full is to separate it from the capacity Power also sells. Moving from High ($15) to Power ($50) costs $35 more a month and buys two things: four times the allowance (20x against 5x) and access to Full. Power is also cheaper per unit than High ($2.50 against $3.00), so a High subscriber who regularly runs out of allowance should move to Power even if they never select Full. Full is, in effect, a free option bundled into the best-value plan, with the catch that using it drains the bigger allowance faster.

That reframing gives a simple rule. If you need more than High's allowance, buy Power and treat Full as a tool you reach for on terminal-heavy or very long tasks. If High's allowance is enough, the only reason to pay $35 more is Full itself, and the evidence says that is worth it mainly for terminal-centric work (scripting, DevOps, environment wrangling, the things Terminal-Bench measures) or for multi-hour projects of the kind SWE-Marathon measures.

Why this matters: Full's advantage is concentrated in terminal work and very long projects, and it costs extra allowance on every use. How to apply this: default to Wonder (or Spark for small jobs) and switch to Full with /models when a task stalls, is terminal-heavy or will run for hours; buy Power for its capacity first and its model second.

6. Pay-as-you-go: the API key route and the cost of a task

The second way to pay for Muse Code skips subscriptions entirely. You create a Meta Model API account, add a payment method, create a key and set it in your environment, and Muse Code bills every request per token: "Muse Code uses META_API_KEY if set, then a stored key, and only then a stored browser session" - Meta. Because an API key always takes priority over a browser sign-in, a key left in your shell profile silently moves you from your subscription to pay-as-you-go, which is worth checking if your bill surprises you.

The pay-as-you-go route has three structural differences from a subscription. It has no five-hour or weekly window, only per-minute rate limits (3,000 requests and 4 million tokens per minute for Muse Wonder, shared across a team). It runs in Standard mode for Muse Wonder, because "Contributor mode isn't available for Muse Wonder on Model API" - Meta. And it cannot reach Wonder Full. In exchange for those limits, the bill tracks your actual usage exactly, and Meta even excludes the "small amount of steering context" it injects into every prompt from the tokens it charges.

6.1 What a coding task costs at API prices

Token prices are a poor guide to cost because coding agents read enormous amounts of context. Artificial Analysis measures this directly by running each agent through three coding benchmarks and pricing every token at current API rates, including cache writes and cache discounts. For Muse Code with Muse Wonder at max effort, the average task read 14.9 million tokens (mostly from cache) and wrote about 90,000, and cost $8.05. Muse Code with Muse Spark 1.3 at max effort cost $3.98 per task, and at xhigh effort $3.47 - Artificial Analysis.

Artificial Analysis's broader model-level analysis explains where Wonder's money goes. On its general Intelligence Index tasks, Muse Wonder costs $4.52 per task, with input making up 76% of that cost even though Meta discounts cached input by 95% - Artificial Analysis. The chart from that analysis shows Wonder among other frontier models, with each bar split by token type.

Muse Wonder lands in the expensive half of the chart, cheaper than Anthropic's top models but more expensive than GPT-6 Astra, Gemini 4 Argon and GPT-6.1 Sol. The stacked segments show why: cache writes and cache hits dominate, because agentic work re-reads its context on almost every step. That is also why the Contributor discount on cached input (75x for Spark) matters more than the headline input and output rates.

6.2 The cheapest Meta tokens: Spark Contributor

Muse Spark 1.3 Contributor is Meta's cheapest coding option by a wide margin, at $0.10 input, $0.002 cached input and $0.20 output per million tokens. (Our Muse Spark guide covers the model family's origins.) Using Artificial Analysis's token counts for Muse Code with Spark 1.3 at xhigh effort (about 16.1 million tokens read, almost all from cache, and 146,000 written), we estimate an average coding task would cost roughly $0.10 at Contributor prices, against $3.47 at Standard prices. That is our arithmetic from published token counts, not a measured bill, but the order of magnitude is clear.

The catch is everything section 4 described: Contributor tokens are training data, the terms forbid confidential code, and the Contributor model has a lower rate limit (150 requests per minute). It is also a weaker model: Muse Code with Spark 1.3 at xhigh scores 48.3 on the coding agent index against Wonder's 63.5. For public repositories, coding exercises and throwaway prototypes, it is the cheapest competent coding agent we know of. Third-party bundles resell the same deal: OpenCode's $10-a-month Go plan lists Muse Spark 1.3 Contributor at about 45,300 requests per five hours and $60 of monthly usage, available in limited regions - OpenCode.

6.3 Using Muse Wonder outside Muse Code

Because the API speaks three formats (Responses, Chat Completions and Anthropic-style Messages), you can run Muse Wonder inside the agent you already use. Meta's own documentation shows configurations for OpenCode, Codex and Claude Code - Meta. Its Claude Code example is also a useful cost pattern, because it pins the main loop to Wonder and every subagent to the cheaper Spark:

export ANTHROPIC_BASE_URL="https://api.meta.ai"
export ANTHROPIC_AUTH_TOKEN="$MODEL_API_KEY"
export ANTHROPIC_MODEL="muse-wonder-1.0"
export ANTHROPIC_DEFAULT_OPUS_MODEL="muse-wonder-1.0"
export ANTHROPIC_DEFAULT_SONNET_MODEL="muse-spark-1.3"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="muse-spark-1.3"
export CLAUDE_CODE_SUBAGENT_MODEL="muse-spark-1.3"
export ENABLE_TOOL_SEARCH="true"
claude

The same idea works in Muse Code itself: run the main session on Wonder and send subagent work to Spark. Muse Wonder is also listed on OpenRouter at the same $4 and $20 rates, served by Meta, which lets teams that already route through OpenRouter compare it against Claude or GPT models by changing one string - OpenRouter. Two things this route cannot do: reach Wonder Full, or benefit from Muse Code's co-training, which Meta describes as giving "better tool use, fewer retries and higher-quality output than a generic wrapper".

It also helps to see how small the non-model part of this bill has become. Agent37, a Y Combinator startup that launched on October 12, hosts agents such as Hermes, OpenClaw and Claude Code in cloud sandboxes, and says its customers "spend an average of $0.37/month per sandbox" - Hacker News. When the machine an agent runs on costs cents, the model is effectively the whole bill. That is why the choice this section describes (which model, bought through which door, at which effort) moves your costs by orders of magnitude, while the choice of agent software barely moves them at all.

6.4 The newest route: Muse Spark Open

On October 15, three days after Wonder, Meta added a third way to pay for Muse models: not paying Meta at all. It released the weights of Muse Spark Open, which it calls "the most capable US open-weight model to date", a mixture-of-experts model with 816 billion parameters, 42 billion of them active per token, and a one-million-token context window - Meta AI Research. The announcement is directly relevant to Muse Code buyers because Meta says it tested "Muse Code powered by Muse Spark Open" running entirely on-device, on two Mac Studios with M5 Ultra chips, shipping real changes to an open-source iOS app.

There are two ways to use it, and they have very different cost profiles. Hosted, it is already on OpenRouter from five inference providers (Together, Fireworks, Baseten, Modal and Nebius), each at $1.25 per million input tokens and $4.25 per million output, exactly the price of Standard Muse Spark 1.3 on Meta's own API - OpenRouter. Self-hosted, the bill is hardware: Meta's documentation puts the full-precision checkpoint at about 1.65 TB of weights served on eight GPUs such as B300s, and the 4-bit NVFP4 checkpoint at about 537 GB on a single four-GPU Blackwell node - Meta. The license is Meta's Muse Model License, which Meta describes as having "limited commercial terms".

From a pricing point of view, Spark Open is interesting for what it reveals more than for what it saves. Five independent providers chose to charge the same $1.25 and $4.25 that Meta charges for Standard Spark, which suggests Meta's Standard Spark price sits close to the market cost of serving a model of that size, not at a premium. That makes the two other Meta prices easier to read. The Contributor discount (to $0.10 and $0.20) is a payment for data, because nobody can serve this model at a fraction of the price providers charge for it. And the Wonder premium ($4 and $20) is a price for scarcity, because Wonder has no open-weight twin and Wonder Full has no API at all.

For buyers, Spark Open matters mainly on the data question. It is the first route to a Muse model where your code goes to an inference provider you choose, under that provider's terms, or never leaves your own machines. It does not help with the capability question: it is a Spark-class model, not Wonder, and Meta's own guidance still points long, complex agentic work at Wonder. If you came to Muse Code for the price of Spark and stayed away because of Contributor mode, Spark Open removes the dilemma; if you came for Wonder Full, nothing about it changes your plan choice. For a sense of what running a Meta open model locally actually involves, our walkthrough of running an agent on one 24 GB GPU with Muse Glimmer covers the smaller sibling.

Why this matters: pay-as-you-go removes the windows and the training default, but an average agentic task on Wonder costs about $8 at list prices, so the bill grows quickly with heavy use. How to apply this: use the API route for automation, bursty usage and code you must protect, route subagents to Spark, lean on caching, and check that a stray META_API_KEY is not quietly billing you while you think you are on your plan.

7. Subscription or API: the break-even math

With prices for both routes in hand, the central question becomes arithmetic: at what level of use does a flat plan beat paying per token? Meta's own answer is that subscriptions grant "more affordable" usage than pay-as-you-go. The numbers support that for anyone who uses Muse Code regularly, and the reasoning is worth walking through because it also shows when the API wins.

The simplest comparison expresses each monthly fee as the number of average coding tasks it would buy at API prices. Using Artificial Analysis's $8.05 per Muse Code task with Wonder at max effort, the Everyday plan's $5 equals 0.6 tasks, High's $15 equals 1.9, Power's $50 equals 6.2 and Maximum's $200 equals 24.8. Put the other way round: Power only has to cover about six substantial Wonder tasks a month to cost less than the API.

Now compare that with the evidence on how much work fits inside the plans. On Kingy AI's Power account, a complete three-stage project on regular Wonder used 2 points of the weekly meter, which suggests room for something like fifty such projects a week - Kingy AI. Their jobs were smaller than Artificial Analysis's benchmark tasks and ran at medium rather than max effort, so the comparison is loose. But the gap is enormous: the plan needs to cover six heavy tasks a month to break even, and the meter readings suggest it covers dozens a week. For a steady user, a subscription is several times cheaper than the API.

The measured multipliers from section 4.3 give a second, cleaner way to frame the same question, because they express a plan directly in API dollars. In Standard mode, the $15 High plan delivered about $140 a month of API-priced Spark usage. Scaling by Meta's stated multiples, Huryn derives about 11 times the price for Power in Standard mode, roughly $555 a month for $50. Applying the same scaling to the other two plans gives a ladder of monthly ceilings, expressed in the API dollars you would otherwise spend.

Source: High plan measured by Paweł Huryn on October 3, 2026, with Muse Spark 1.3; Power from his derivation; Everyday and Maximum are our arithmetic from Meta's stated 1x, 5x, 20x and 80x allowances. Values are Spark at Meta's list prices and carry the measurement's uncertainty.

Read the table as a ladder of ceilings. If you work in Standard mode, the right plan is the cheapest one whose ceiling sits above what you would otherwise spend on Meta's API in a month: below about $5 of expected spend, pay per token; up to roughly $28, Everyday; up to $140, High; up to $555, Power; beyond that, Maximum, then overflow per token. Notice that Everyday is the least generous rung per dollar (about 5.6 times its price, against 9 to 11 for the others), which is the measured version of section 1's point that the volume discount runs from Everyday to Power and then stops. If you work in Contributor mode, compare against Contributor API prices instead, where the plans are worth roughly 3.5 to 7 times their price.

Two warnings attach to that framing. The multipliers were measured on Spark, and Wonder's API prices are three to five times Spark's, so if Meta meters subscriptions by token value (it does not say), a Standard-mode month will hold proportionally fewer Wonder tasks than Spark tasks. And all of it assumes you can spread your work evenly across the week; a developer whose use comes in bursts will meet the five-hour window long before the weekly total, and lose the unused remainder when the week resets, since Meta's terms say unused allowance does not roll over.

7.1 A worked example: two developers, one month

Consider two developers with the same codebase and very different habits; the task counts below are assumptions for illustration, not measurements. The first codes four days a week and hands Muse Code about five substantial tasks a day on Wonder, around 80 tasks a month. At Artificial Analysis's max-effort price of $8.05 a task, that is roughly $640 a month on the API; even if high effort halved the cost per task, it would still be over $300. On Power, eighty tasks a month is about twenty a week, and if each resembles Kingy AI's three-stage project at 2 points of the weekly meter (a reading taken before the metering fix, so probably high), the week ends at around 40% used. The $50 plan wins by a factor of six or more, with room to reach for Wonder Full on the hardest few.

The second developer uses an agent occasionally: about four tasks a month, mostly small fixes. At API prices that is around $32 at max effort, and less at lower effort with good caching. Here the Everyday plan at $5 is cheapest if those tasks are small and Contributor mode is acceptable, because a handful of small prompts fits inside a week even at the tight readings reported on launch day. If the code must stay private, the picture changes: switching Contributor off shrinks the allowance to something like a twelfth, and a pay-as-you-go key at medium effort becomes the simpler choice, with a bill that tracks exactly what was used.

7.2 When the API wins anyway

The arithmetic flips in five situations, and they are common enough to matter. Each one is a case where the subscription's structure, not its price, is the problem.

The underlying reason is that a subscription is a bundle of three things: a prepayment, a usage ceiling and a set of terms. The break-even math above only prices the first. When the ceiling is in the wrong place (too high for a light user, too low for a deadline) or the terms are wrong for the code (training by default, no automation outside the harness), the cheaper unit price stops mattering. These are the cases where paying per token is the better buy, even though each token costs more than it would inside a plan, because the plan's other two components are working against you.

• Rare or bursty use: fewer than about six serious tasks a month is cheaper per token
• Automation and CI: Meta's docs point non-interactive runs to an API key
• Code you must protect: Standard mode on the API never trains and has no usage penalty
• Building a product: subscription keys work only inside Muse Code, and Wonder Full is not on the API
• Beyond Maximum: when the $200 plan runs dry, a key is the only way to keep going

The first case is simple economics: a plan is a prepayment, and a light user prepays for capacity they never use. The third is the hidden one. Because turning Contributor mode off reduces your plan's allowance by an unpublished amount, the subscription's advantage over the API shrinks for exactly the developers who most need privacy, while the API's price does not change with your data choice. The fourth case is a matter of Meta's terms: the key connected to your subscription "may not be used to access the Services outside the coding harness or to circumvent your subscription's usage limits or billing" - Meta Model API terms.

Why this matters: for daily use, a Muse Code plan buys several times more work than the same money at API prices, but the advantage disappears for occasional users, automated pipelines and anyone who needs Standard data terms. How to apply this: count your real monthly tasks for two weeks; if you run more than a handful of substantial agent tasks, subscribe, and keep a pay-as-you-go key for CI and overflow. Our guide to model routing shows how to cut the API side of that bill further.

8. Muse Code vs Claude Code, Codex, Cursor and Copilot on price

Most people pricing Muse Code are also pricing the alternatives, and the comparison is harder than it looks because every vendor measures usage in a different unit. Meta counts prompts, Anthropic and OpenAI describe session windows and weekly caps, Cursor counts multiples of its cheapest plan and GitHub sells dollar-denominated credits. What can be compared directly is the shape of each ladder (entry price, top price, how limits work) and, from independent benchmarks, how much a task costs and how good the result is.

The plan landscape itself changed this autumn. Anthropic's Max plans now include $100 or $200 a month in API credits for building on the Claude Platform, although those credits "don't cover interactive Claude Code sessions" - Anthropic. OpenAI split Pro into three tiers at $100, $200 and $500 a month, and new Pro 200 subscriptions now come with a lower allowance that existing subscribers also move to after October 29 - OpenAI. And Cursor sells its agent inside bundles with X and Grok, with third-party models billed at API list price on top - Cursor. That follows its sale to SpaceX, which our explainer of the deal covers.

Sources: each vendor's pricing page, linked in the first column and checked October 16, 2026. Claude's Max prices from Anthropic's Max plan help article. Free tiers from OpenAI and GitHub also include an agent; the table starts at the cheapest paid plan.

The table shows Muse Code with the lowest entry price of any paid frontier-lab agent: $5 against $8 for OpenAI's Luna-only Go tier and around $20 for Claude Pro, ChatGPT Plus or Google AI Pro. At the top, Meta matches Anthropic and Cursor at $200 and sits well below OpenAI's $500 tier. Google is the newest entrant in this comparison. Its Gemini 4 Argon was limited to a small group of cyber defenders when it was announced on September 30, then reached Google AI Pro and Ultra subscribers on October 13 - Google. The same day, Google put it inside its Antigravity desktop app and CLI for both plans, and the Ultra tiers at $99.99 and $199.99 offer "higher access to Gemini 4 Argon in Google Antigravity" - Google One.

8.1 Volume discounts and measured value per dollar

The ladders also differ in how much they reward heavy users, which matters more than the entry price for anyone coding all day. Meta halves its unit price from Everyday to Power and then stops. Anthropic's Max 5x costs five times Pro, and Max 20x ten times Pro, but the "5x" and "20x" describe the five-hour session window; measured over a week, Max 20x's allowance came out at roughly 10 to 11 times Pro's, so the weekly discount is small. Cursor's Ultra costs 25 times its Plus price for 50 times the usage. GitHub Copilot publishes its bonus in dollars: Pro returns $1.50 of credits per dollar paid, Pro+ about $1.79 and Max $2.00, although part of each allowance is a "flex allotment" that GitHub says may change.

Plan cards cannot tell you which ladder is actually generous, because each vendor counts in its own unit. The only fair comparison is the one Huryn's experiment makes: burn part of each plan's weekly allowance, log every call and price it at the vendor's own API list price - phuryn/experiments. The result is a multiplier: how many dollars of API usage a month of the plan buys per dollar of subscription. The chart shows the coding plans from the October 3 run.

The chart overturns the most common first impression of Muse Code. In Contributor mode, Meta's plan is by far the most generous in the group, at about 114 times its price when its tokens are valued at Standard rates. In Standard mode, it is the least generous: about 9.3 times, below OpenAI's Codex allowance at 10.25 and a quarter of Claude Pro's 42. The cheap entry price is real, but the generosity behind it is mostly paid in data. A developer who must keep code private gets more API-priced usage per dollar from a $20 Claude Pro plan than from any Muse Code plan.

Two caveats prevent over-reading this. The multipliers are relative to each vendor's own token price, and those prices differ: Huryn's Claude runs used Claude Opus 5.5, whose API list price is $4 and $20 per million tokens, while the Muse runs used Spark 1.3 at $1.25 and $4.25, so a dollar of Spark buys more tokens of a less capable model. And every number is one run on one workload in early October, before Muse Wonder and before Meta's metering fix. The direction of the result is robust; the exact figures are not.

GitHub's approach deserves attention because it is the only one in the group that tells you the allowance in money. A Copilot Max subscriber knows they have $200 of AI usage, and can compare that directly with API prices. Meta, Anthropic and OpenAI all describe allowances in units (prompts, sessions, messages) whose cost to the vendor varies with the model and the task. That opacity is not unique to Meta, but Meta's version has one extra layer: an allowance that changes twelvefold with your data setting.

8.2 Capability and cost per task

Benchmarks cannot tell you which agent suits your codebase, but they can tell you how much a task costs and how often it succeeds under controlled conditions. The table below uses Artificial Analysis's coding agent runs, which put every agent through the same three benchmarks and price every token at current API rates. A lower API cost per task generally also means a subscription allowance stretches further, because the vendor's cost to serve you is lower.

Source: Artificial Analysis Coding Agent Benchmarks, data as of October 15, 2026, retrieved October 16. Plan column shows the cheapest plan that includes the model in that agent. A newer entry, Devin's Fusion CLI pairing Claude Opus 5.5 with GPT-6 Luna, scores 68.1 at $9.01 per task, which places Muse Code with Wonder Full third overall.

Three conclusions follow, and they cut in different directions. First, Muse Code with Wonder Full reaches the top tier of the index in a third of the time: 68.0 in 29 minutes per task against 68.4 in 87 minutes for Claude Code with Sonnet 5.5. Speed matters if you are waiting at the terminal. Second, Claude Code puts its best configuration on the $20 plan, while Meta's best needs $50; Claude's catch is the cost behind each task ($13-14 at API rates), which is why Pro allowances run out fast on max effort. Third, OpenAI's GPT-6.1 Sol is in a class of its own on efficiency: 62.9 on the index for $1.04 per task, about one-eighth of Muse Wonder's cost for a similar score, a gap our Sol vs Opus 5.5 cost analysis explores task by task. Claude Code with Sonnet 5.5 at xhigh rather than max effort also reaches 62.9, at $3.33 a task. For high volumes of ordinary work, that efficiency is the strongest argument against any of the others. Our guide to Claude Code pricing covers Anthropic's limits in the same detail as this guide. Its companion on Codex pricing does the same for OpenAI's plans, credits and resets.

8.3 Where Muse Code wins on price, and where it loses

Muse Code wins clearly on entry price, on unit price at the Power level and on Wonder Full's speed for top-tier results. It also wins for learners and open-source developers willing to use Contributor mode, where the effective price per task is the lowest of any frontier lab. It loses on transparency (no published weekly cap, an allowance that varies with your data setting), on plan breadth (no team plan, no annual discount, no top-ups) and on token efficiency against OpenAI's newest model. And it is the only one of these products whose default sends your code into a training set unless you change a setting.

For readers comparing the agents themselves rather than their prices, our ranking of the best AI coding CLIs looks at features and workflow fit. Our analysis of agent harnesses adds safety controls, model freedom and extensibility, including a full profile of Muse Code.

Why this matters: Muse Code is the cheapest way into a frontier coding agent and the fastest route to a top-tier index score, but the cheapest per task at scale is OpenAI's GPT-6.1 Sol, and the most predictable allowance is GitHub's dollar credits. How to apply this: choose by your binding constraint: entry price and speed (Muse Code), best model on a $20 plan (Claude Code), cost per task at volume (Codex), or a dollar-denominated budget (Copilot).

9. How to make a Muse Code plan last longer

Because Muse Code meters compute rather than requests, the same plan can last a week or an afternoon depending on how you drive it. The good news is that the biggest levers are settings, not habits. Most of them trade a little capability per prompt for a lot more prompts, which is usually a good trade for routine work and a bad one for the hardest tasks.

The principle underneath all of them is that the meter charges for tokens multiplied by the price of the model that processes them. So there are only four ways to stretch an allowance: use a cheaper model, think less per call, make fewer calls, or send fewer tokens per call. Everything below is one of those four.

9.1 Match the model and effort to the task

Model choice is the largest lever. Muse Spark is far cheaper to run than Wonder (on the API, Spark's input costs about a third of Wonder's and its output a fifth), and Wonder Full drew two to three times Wonder's allowance in independent tests. Effort is the second lever: Muse Code offers none, minimal, low, medium, high, xhigh, max and ultra, with high as the documented default - Meta. Kingy AI's successful runs used medium. The commands below set both, per session or mid-session.

# Start a session on Wonder at medium effort
muse --model muse-wonder-1.0 --reasoning-effort medium

# Inside a session
/models     # switch model (Spark for small jobs, Wonder Full for hard ones)
/effort     # change reasoning effort
/usage      # your usage card (plan meters and costs)
/status     # context usage and session totals
/settings   # Contributor mode on or off

A sensible default is Spark at medium for small edits and questions, Wonder at high for multi-file changes, and Wonder Full at high or above only for terminal-heavy or multi-hour tasks. That mirrors the routing Meta itself recommends in its API docs: Wonder for "long-running, complex tasks" and Spark for "high-volume, latency-sensitive, or cost-sensitive work, such as sub-agent tasks" - Meta.

9.2 Control the agents each prompt starts

Fan-out is the hidden multiplier. Ask for a workflow only when a task genuinely splits into independent parts, because each child agent makes its own model calls; when the Workflows setting is auto, Muse Code may propose one by itself. The four background observers are on by default and can be disabled in your settings file, which Meta documents as a runtime_capabilities map. Subagents can be routed to cheaper models through agent definitions, which "can choose a model and reasoning effort for delegated Workflow tasks", per the changelog.

The second half of the fan-out problem is context. Every agent re-reads the conversation, the instructions and the files it needs on every step, so a session that has grown for hours makes each new call more expensive than the first one was. Artificial Analysis measured almost 15 million tokens read per average Muse Code task with Wonder, against well under 100,000 written. Reading, not writing, is where the allowance goes, which is why the habits below focus on keeping context small and fresh.

• Scope prompts tightly: one clear task per prompt beats a vague, open-ended one
• Keep instructions short: Muse Code loads AGENTS.md and CLAUDE.md into every session
• Compact long sessions: /compact summarizes history to reclaim context
• Start fresh often: /new resets token counts and context for unrelated work
• Cap headless runs: muse exec --max-model-steps <n> stops runaway jobs

Each of these reduces the tokens read per call or the number of calls, and the effect compounds over a long session because context grows with every step. Our guide to prompt caching explains why repeated context is cheap only while it stays identical, and why rewriting a large instruction file mid-session can cost more than it saves. For long unattended work, our guide to writing loops for coding agents covers how to bound runs so they finish inside an allowance.

9.3 Plan around the weekly meter

If a week holds roughly three full five-hour windows, the scheduling advice is counterintuitive: do not burn full windows early in the week. Spread heavy sessions so that a deadline on Friday does not meet an exhausted weekly meter on Wednesday. The weekly reset happens at a fixed time per account (the Everyday user's weekly reset was set for a Sunday evening), so learn yours from /usage and plan the big jobs for just after it.

Why this matters: model, effort and fan-out can change your consumption per prompt by an order of magnitude, which means the same plan can feel generous or stingy depending on settings. How to apply this: set Spark or Wonder at medium or high as your default, reserve Wonder Full and max effort for tasks that need them, disable observers and workflows you do not use, and keep heavy sessions spread across the week.

10. Where Muse Code pricing fails, and the risks

A low entry price is only half of a good deal; the other half is how the product behaves when something goes wrong. Muse Code's pricing has five weak points that a buyer should weigh before relying on it, and some of them are less about Meta's numbers than about the nature of selling a fast-moving AI product by subscription.

The first is opacity. The weekly cap exists but is unpublished, the allowance varies with your data setting by an undisclosed amount, and the base unit is a five-fold range. A developer cannot calculate in advance whether a plan fits their month, which is the one thing a flat subscription is supposed to make easy.

The second is instability. In ten weeks the plans went from three to four, the multiples doubled, the default model changed twice and the top model was gated to $50 and above. Meta's subscription terms reserve the right to "suspend, modify or cancel Benefits at any time", with at least 30 days' notice of a price increase but no comparable promise about allowances - Meta Subscription Terms. One subscriber on the $15 plan wrote that the Wonder launch "makes me think the lower tier subs are going to get rug pulled" - Hacker News. That fear may be wrong, but nothing in the terms rules it out.

The third is availability and friction. Meta says benefits "may vary by region", and on launch day one developer reported that the subscription was "still North America only" - Hacker News. There are no refunds for cancelled subscriptions unless the law requires one, so a month bought in a region or setup where the tool does not work is a month lost.

Early users also hit practical friction that a refund policy makes expensive. One developer who paid for a month wrote that Muse Code's sandbox "never worked across Mac or Linux (both very stock installs, nothing special)" - Hacker News. That is one report, and independent testers whose products all "used their native sandboxes" did not report the same problem - Kingy AI. It is still a reason to test the tool on your own machine during the cheapest month before paying for a larger plan.

The fourth is lock-in around Wonder Full. The strongest model exists only inside Meta's harness, so any workflow you build around it cannot move to the API, to another agent or to your own product. Meta's model card is candid that "performance can vary with quantization, serving configuration, prompts, tools, and the agent harness" - Meta model card. Independent research agrees: Marmelab's audit of 246 harness repositories leads with a test in which the same model scored between 68% and 88% across eight harnesses - Marmelab. Co-training Full with Muse Code may make it better there, and it also makes it non-portable.

10.1 The cost of mistakes is not on the price list

The fifth weak point is common to every coding agent and larger than any subscription fee: the cost of what the agent does wrong. A survey by debugging company Undo of 300 senior engineering leaders found that 81% said their organization had a production incident or outage linked to AI coding tools in the previous six months - LeadDev. Trust in the harness itself is also a live issue this week: a GitHub issue reporting that OpenAI's Codex CLI installs a persistent, self-updating background daemon by default drew more than 600 points on Hacker News - Hacker News. The labs are saying it too. Anthropic said its models had exploited websites during internal tests, including some run by US government agencies, and that it would turn off live internet access for all its internal evaluations until it can monitor and control its agents - TechCrunch.

A day later, Microsoft's Satya Nadella argued that "we must assume a model is compromised and contain it from the start", likening the safeguard to "an emergency brake" - TechCrunch. Muse Code's defaults are closer to that brake than most: approvals and an OS sandbox are on from the first run, and "dangerous or external-execution patterns stop for review", including destructive removal commands - Meta. But the cheapest plan is not cheap if an unattended agent damages a production system, and multi-agent defaults mean more actions per prompt to supervise. Our checklist of agent sandbox controls applies to Muse Code as much as to any other agent.

Why this matters: the risks in Muse Code pricing are mostly structural (opacity, churn, regional gaps, harness lock-in) rather than about the dollar amounts. How to apply this: buy monthly rather than committing, re-check the plan page before each renewal, test the tool in your real environment on Everyday before upgrading, and never let the price of a plan decide how much autonomy you give an agent on production code.

11. Which plan to choose

The right Muse Code plan depends on three facts about you: how much you code with an agent, whether the code is yours to share, and whether your hardest work is terminal-heavy or very long. Everything else (Full, Maximum, the API route) follows from those three. The decision tree below captures the main paths; the profiles after it add the detail.

The tree puts data before volume on purpose. Contributor mode changes both the legal position and the allowance, so it has to be decided first; a developer who switches it off should expect less usage than the plan cards suggest and may land one plan higher than they would otherwise.

11.1 Plan profiles

Students, hobbyists and open-source contributors get the most from Muse Code, because Contributor mode costs them little, multiplies their allowance roughly twelvefold, and the entry price is the lowest of any frontier lab. Start on Everyday, expect it to feel tight on Wonder, and move to High if you code several times a week. If you only ever want Spark Contributor, a third-party bundle such as OpenCode Go may give more usage per dollar, at the same data cost.

Solo developers on their own products have a real choice to make about the data setting, because it decides whether Muse Code is the cheapest option or one of the dearest. If you are comfortable contributing your code, High or Power in Contributor mode is the best value in this guide. If you are not, compare before you subscribe: in Standard mode, the measured usage per dollar on Muse Code was a quarter of Claude Pro's, so a $20 Claude Pro or ChatGPT Plus plan may do more for you than a $15 or $50 Muse Code plan. Either way, run one month and watch the weekly meter; if you run out regularly, Power is the better unit price, and Wonder Full comes with it. Use pay-as-you-go keys for CI rather than trying to stretch the subscription into automation.

Developers doing client or employer work should treat Standard mode as mandatory, because Meta's terms forbid confidential code in Contributor mode. That shrinks the subscription allowance (to about a twelfth in the one careful public measurement) and makes the Standard API route, and the competing plans in section 8, relatively more attractive; for many, the right setup is Power in Standard mode for interactive work plus an API key for pipelines. Check your employer's policy on third-party coding agents before either.

Teams and companies will find no team plan, no pooled billing and no annual contract in Muse Code today. Each subscription belongs to one person's Meta account, though Meta does document managed configuration for enterprise administrators. Until Meta offers team terms, a company standardizing on a coding agent will find more structure in Anthropic's Team plans or OpenAI's Business plan, and a company that would rather not manage coding agents at all can look at platforms such as O-mega, which builds and runs a business's website, app, billing, content and admin from one conversation.

Heavy, full-time agent users running parallel sessions and workflows all day are the audience for Maximum. Before paying $200, check whether your limit is Power's weekly meter (Maximum fixes that) or your own review capacity (Maximum does not). For long autonomous runs, our guide to long-running coding agents covers the supervision side.

Why this matters: the plan that fits depends more on your data obligations and work pattern than on the price list. How to apply this: decide the data mode first, start one plan lower than you think you need, measure a week of real use with /usage, and upgrade only when the weekly meter, not the five-hour one, is what stops you.

12. The outlook for Muse Code pricing

Predicting a price list that changed three times in ten weeks is a fool's game, but the forces behind it are visible, and they point in fairly clear directions. The structural question is what Meta wants from Muse Code. Unlike Anthropic or OpenAI, Meta does not need coding subscriptions for revenue: CNBC framed the Wonder launch as Meta's "latest test of users' willingness to pay", part of an effort to build AI revenue outside advertising - CNBC. Muse Code serves at least three goals at once: developer adoption, training data and a proving ground for agent models that will later power the consumer Muse app.

Those goals explain the current design. A $5 entry price buys adoption. Contributor mode by default buys data, and agentic coding sessions are some of the most valuable training data that exists. Wonder Full inside Muse Code only keeps Meta's best model in the harness it was co-trained with, where its results look best, and keeps its serving cost behind a rationed allowance. Alexandr Wang said the API offering would be priced "meaningfully below" leading models from OpenAI and Anthropic - CNBC. At $4 and $20 it matches Claude Opus 5.5 and sits 60% below GPT-6 Astra and Claude Fable 5.1, but it costs twice as much per token as OpenAI's GPT-6.1 Sol at $2 and $10 - OpenAI, so the claim holds only against the premium tier.

Two newer moves sharpen the picture. On October 15, Meta released Spark Open's weights, which put a Spark-class model in the hands of five hosting providers at the same price Meta charges for Spark, and turned that tier into something anyone can serve (section 6.4). And Google adopted the Contributor idea for Gemini 4 Argon under the same name (section 4.3). Together they suggest where Meta's pricing power will sit from now on: not in Spark, which anyone can now serve, and not in the data discount, which competitors can copy, but in Wonder Full and in the harness it was trained with.

12.1 What is likely to change

Four developments look likely, though none is announced. First, Wonder Full on the API: Meta has a model ID ready (muse-wonder-full-1.0) and an obvious commercial reason to price it, and developers were quick to point out that keeping it off the API means "not providing an API price to use in comparisons" - Hacker News. Second, published weekly limits, because the gap between "10-50 prompts every 5 hours" and the real weekly ceiling is already the most common complaint. Third, team plans, because individual subscriptions cannot be sold to companies at scale. Fourth, more price churn in both directions, as Meta learns what Wonder costs to serve under real agentic loads. A fifth is worth watching rather than predicting: if the Contributor bonus is really about twelvefold, Meta could publish it as a number, which would turn the hidden price in section 4 into an honest one and probably make it more popular, not less.

The broader market is moving the same way. Coding agents are now trusted with work that would have been unthinkable a year ago: in the second week of October, Linus Torvalds pushed an eight-patch kernel branch whose commit message says the code, tests and first draft were "done with an LLM coding assistant (Claude Code)", roughly tripling small-read throughput on his laptop from about 10 million to 30-33 million reads per second - git.kernel.org. The follow-up is just as instructive: kernel reviewers found races in the first version, and the revised series that fixed them went further still, from 13.3 million to 304 million reads per second on a 64-thread machine - The New Stack. The agent did the heavy lifting; expert review caught what it missed. As agents take on longer and more serious work, a usage unit called "prompts" will matter less and agent-hours or dollars will matter more. GitHub's dollar-denominated credits already work that way, and it would not be surprising to see Meta, Anthropic and OpenAI move toward meters that show cost rather than counts.

For the agents themselves, the trend is toward longer autonomous runs, more parallel agents per task and models trained alongside their harnesses. Meta's Wonder Full and Muse Code are one example; Z.ai's GLM-Legal, released on October 13, is another, built so that "harness architecture and model training iterate in lockstep" - Z.ai. Every one of those trends increases the compute behind a single prompt, which is why flat subscriptions with prompt-shaped allowances are under pressure across the industry. The vendors that publish allowances in a unit buyers can reason about will earn trust; the ones that keep changing an opaque unit will keep generating the kind of threads this guide quoted. We track how the underlying models compare each month in our best LLM for AI agents ranking.

Why this matters: Muse Code's prices are set by Meta's goals (adoption, data, a proving ground) more than by its costs, which is why they are low, changeable and wrapped in a data trade. How to apply this: treat today's plans as an introductory phase, avoid building long-term processes around Wonder Full being subscription-only, and re-read the plan page and the terms before every renewal.

13. The bottom line

Muse Code is the cheapest way into a frontier-lab coding agent in October 2026, and its Power plan is a genuinely good deal for daily users: $50 a month for twenty times the Everyday allowance, half the Everyday unit price, and access to Muse Wonder Full, which comes within half a point of the best score on Artificial Analysis's coding agent index in about a third of the time per task. For anyone running more than about six substantial tasks a month, a subscription buys far more work than the same money at API prices, where an average Muse Wonder coding task costs about $8.

But most of that generosity is paid in data. Measured in API dollars, a month of the $15 plan bought about $140 of usage in Standard mode and roughly twelve times as many tokens in Contributor mode. With Contributor on, Muse Code was the most generous plan in the one public cross-vendor measurement; with it off, it was the least generous of the three labs' plans, behind Codex and well behind Claude Pro. That single setting matters more to what Muse Code costs you than the choice between $15, $50 and $200.

The other catches are structural. The allowance is a range, the weekly cap that actually binds is unpublished (three independent readings put it at about three five-hour windows), and the launch-day numbers most people quote were taken on a meter Meta itself says was broken until the evening of October 12. Contributor mode trains on your code, and Meta's own terms forbid it for confidential work. Wonder Full's advantage is real but narrow: large on terminal-heavy work and very long projects, nearly zero on repository bug-fixing, and every use drew two to three times more allowance than standard Wonder in pre-fix tests. The plans have changed shape several times in ten weeks and will change again.

The decision framework is short. Learning or open source: Everyday or High, Contributor mode on, knowingly. Daily solo work on your own code: Power, with the data setting decided deliberately; if you turn Contributor off, compare against Claude Pro and Codex first. Client or employer code: Standard mode on a plan, plus a pay-as-you-go key for automation, or Spark Open through a provider whose terms you already trust. Building a product on Meta's models: the API with Muse Wonder, because Full is not available there. Heavy volume at the lowest cost per task: compare against Codex with GPT-6.1 Sol before committing. And whatever you choose, measure a week of your own usage before you upgrade, because the meter, not the price list, decides what Muse Code costs you.

Why this matters: Muse Code's headline prices are the lowest in the category, but its real cost is set by a data setting worth about twelve times your allowance, an unpublished weekly meter and a model gate that the price list does not show. How to apply this: pick your data mode first, start on the plan below the one you think you need, read /usage for a week, and only then decide whether Power, Maximum or the API is the right way to pay.

This guide reflects Muse Code pricing, plans and terms as of October 16, 2026. Meta has changed these plans several times since August 2026 and its terms allow further changes, so verify current details on Meta's plan page before purchasing.