Meta's Muse Models Arrive on Google Cloud: What the Preview Really Changes

Muse Wonder, Muse Spark 1.3 and Muse Ember are now served from G​oogle Cloud as well as from M​eta's own Model API. All three appear in G​oogle's partner-model documentation marked Preview and reachable through one global endpoint, and the listing was reported on 9 November 2026 — the same day M​eta launched Muse Ember. Nothing about the checkpoints changed in the move. The model IDs are still muse-wonder-1.0, muse-spark-1.3 and muse-ember-1.0; the context windows are the same; the prices on M​eta's rate card are the prices. What changed is the contract you sign and the URL your SDK points at, and for a fair number of enterprises that was the actual blocker rather than the model.

So treat this as a distribution story, not a capability one. Muse Wonder was released on 12 October 2026, Muse Spark 1.3 on 2 September, and Muse Ember on 9 November. None of them is new this week; what is new is that a G​oogle Cloud customer can now call them without opening a second vendor relationship, and that is worth understanding precisely, because the preview has edges that the announcement coverage did not dwell on.

Three models, three different jobs

M​eta's own framing is the cleanest way to hold the family in your head: Wonder plans, Ember handles the volume, Spark does the coding grind. The three are not tiers of one model, and the price spread between them — a factor of forty on input — reflects that rather than a marketing ladder.

• Muse Wonder — M​eta's frontier reasoning model, released 12 October 2026, positioned for complex software engineering and long-horizon agentic work; 1,048,576-token context; text, image, audio and video in, text out; reasoning effort adjustable from minimal to max, with max as the default

• Muse Spark 1.3 — the 2 September release tuned for agentic workflows and competitive coding, with built-in tool calling and Model Context Protocol support; 1M-token context; the cheapest of the three on both sides of the meter

• Muse Ember — the 9 November launch, built for high-volume agent execution: tool calls, coding subtasks, routing, extraction and long-document parsing; 1M-token context and up to 512K tokens of output; multimodal input like its siblings

• Availability variants — Muse Wonder and Muse Spark 1.3 also exist in cheaper "Contributor" or subscription-only forms where M​eta gets training rights or a monthly fee in exchange for the discount; the G​oogle Cloud preview serves the standard pay-as-you-go endpoints

The endpoint, and what "preview" is doing in that sentence

G​oogle's documentation is short and specific, and the specifics matter more than the headline. Requests go to a publisher path under aiplatform.googleapis.com, with the model named bare in the model field rather than with a publisher prefix:

• Endpoint — POST https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/m​eta/v1/responses, authenticated with a G​oogle Cloud access token from gcloud auth application-default print-access-token

• Interface — the stateless, O​penAI-compatible Responses API; the docs are explicit that stateful response storage (store: true) is not supported, and streaming is available over SSE if you would rather not wait for the whole answer

• Region — global only. There is no regional endpoint listed for any of the three models, which is the single most consequential limitation in the whole preview and one that procurement teams should read twice

• Status — Preview, per G​oogle's partner-model listing. No SLA, no deprecation clock and no capacity guarantee is published alongside it

• Responsibility — G​oogle states plainly that M​eta's models are not a G​oogle product and fall under the provider's own terms as a "Separate Offering", which means the support path for a bad output runs to M​eta, not to G​oogle Cloud support

That combination — global endpoint, stateless API, third-party terms — is not a reason to avoid the preview. It is a reason to know what you are testing. If your architecture needs EU or US data residency at the request level, a global endpoint is a compliance question you have to answer before the first token, not after. If your application relies on the provider storing conversation state between turns, you are now responsible for that state yourself, which is a small amount of code and a real change to how you count cost and latency.

Ember is the launch hiding inside this story

Of the three, only Muse Ember is genuinely new, and it is the more interesting engineering claim. M​eta describes it as the first model trained using Muse Wonder Full — the higher-capability Muse Wonder variant that is not sold per token at all, only inside the two most expensive Muse Code subscription tiers. That makes Ember a distillation story wearing a pricing story's clothes: the flagship teaches, the small model executes.

The published numbers, all M​eta-reported and none of them independently reproduced at the time of writing, put Ember close to A​nthropic's Claude Haiku 5.5 on several agent evaluations while costing a fraction as much per completed task:

• Price — $0.10 per million input tokens and $0.50 per million output, with cached input at $0.004; above 200,000 input tokens the long-context rates of $0.30 and $1.50 apply to the entire request, not just the excess

• Artificial Analysis Intelligence Index — 36 for Ember against 37 for Muse Spark 1.3, with a cost per index task of $0.14 versus $2.39, which is the striking figure rather than the one-point gap

• Agent and coding evaluations — AutomationBench-AA 37.8%, Agents' Last Exam (Linux) 61.6%, Terminal-Bench 4.0 40.9%, Coding Agent Index-AA 46 and OSWorld 2.1 69.5%, all M​eta-reported; FrontierCode 2.0-AA at 27.2% is the one row where Haiku 5.5 leads at 34.9%

Read those with the usual discount. M​eta's launch material mixes internal evaluations, vendor-supplied third-party runs and estimates, and the comparisons quietly assume list prices for everybody. The one number worth trusting without qualification is the rate card, because a rate card is a contract.

Where the bill actually comes from

G​oogle's partner-model page for M​eta does not publish per-token rates, and no G​oogle-specific price list for these three appeared with the listing. The published rate card is M​eta's, and it is the one to budget against until G​oogle says otherwise:

• Muse Wonder — $4.00 input, $20.00 output and $0.20 cached input per million tokens, with the same rate at any context length and no long-context surcharge

• Muse Spark 1.3 — $1.25 input, $4.25 output and $0.15 cached input per million; the Contributor variant drops to $0.10 and $0.20 in exchange for training rights over your traffic

• Muse Ember — $0.10 input and $0.50 output per million up to 200K input tokens, then $0.30 and $1.50 for the whole request

• Metered extras — web search grounding adds $2.50 per 1,000 queries on any of the text models, and rate limits are counted per team rather than per key, at 3,000 requests and 4,000,000 tokens per minute on the standard tiers

The pricing structure has one trap worth naming: Ember's long-context tier is triggered by total input tokens, cached ones included, and it reprices the entire request rather than the overflow. An agent that carries a 210K-token transcript across every turn pays triple on every turn, not on the last one. That is the sort of detail that turns a cheap model into an expensive invoice, and it is invisible on a per-token comparison chart.

What this changes for a buyer, and what it does not

If your organisation already runs on G​oogle Cloud, the preview collapses a procurement step. Identity, billing, quota management and network egress now sit inside a contract you have, and a team can evaluate Muse Wonder without a new vendor security review — which is usually the two-month item, not the integration. That is the real content of the announcement, and it is a bigger deal for adoption than any benchmark row.

If you are not on G​oogle Cloud, or you need regional endpoints today, nothing about your situation changed on 9 November. M​eta's own Model API still serves all three, still publishes the same rates, and still gives you the stateful conveniences that the G​oogle preview removes. The choice between the two is a contract question before it is a latency question.

There is a third position, and it is the one we occupy. OrcaRouter does not carry Muse Wonder — so if Wonder is the model you need, M​eta's API or this G​oogle preview is where you get it, and we will not pretend otherwise. What we do carry from the family is Muse Spark 1.1 and Muse Spark 1.2, both at M​eta's own $1.25 and $4.25 per million tokens with zero markup, sitting in the same catalogue as 200-plus other models behind one API key. For teams whose workloads are mostly Spark-shaped, that means one contract instead of two, and automatic failover across providers when a preview endpoint has a bad afternoon — which, on preview terms, is a thing that happens.

What to watch next

Three signals will tell you whether this preview becomes infrastructure. The first is regional endpoints: a global route is fine for a prototype and awkward for a regulated workload, and G​oogle's docs will gain regions only when the serving capacity exists. The second is a G​oogle-published rate card for the three models — if G​oogle prices above M​eta's list, the preview's procurement advantage gets eaten by a margin, and if it prices at parity, the "one contract" argument gets a lot stronger. The third is general availability, with whatever SLA and deprecation policy comes with it; preview terms are where a model lives until someone has to put it in a contract.

Until then the honest reading is this: M​eta spent October proving it can build a frontier model and November proving it can get one distributed. The G​oogle Cloud listing is the second of those, and it is the less glamorous half of the work — but it is the half that decides whether a model gets used by teams who never read a launch post.