Meta AI - Tygart Media

Category: Meta AI

The Tygart Media Meta desk: Meta AI, the Model API, and the Muse family, run in the open.

  • Wonder Full Stays in the Seat. The API Key Is a Different Promise.

    Wonder Full Stays in the Seat. The API Key Is a Different Promise.

    On October 12, 2026, Meta launched two models that share a name and almost nothing else. Muse Wonder is a product you can call: it sits on the Meta Model API at $4.00 input, $0.20 cached input, and $20.00 output per million tokens, and inside Muse Code. Muse Wonder Full is a model you can only sit in front of: it exists exclusively inside a Muse Code subscription, on the Power Usage and Maximum Usage plans. The decision an operator makes before pointing either one at a real repository is not which model is smarter. It is which promise they are buying — and the seat’s default promise is not the one most buyers think they made.

    The frontier model is a seat, not a SKU

    Meta’s own availability table is the whole story in four cells. Muse Wonder (muse-wonder-1.0): available on the Model API, standard mode only, and in Muse Code on pay-as-you-go and every plan. Muse Wonder Full: not available on the API at all — Power Usage and Maximum Usage subscriptions only.

    There is no back door. Setting reasoning effort to “max” on muse-wonder-1.0 does not select Wonder Full; Meta’s models page says so in plain words. Meta publishes no API model ID for Full. A team that wants Full behind its own product has, in the words of one launch-week review, no path at any price — businesses can test it inside Meta’s coding environment and cannot deploy it through the standard API.

    The seat prices are printed on the Muse Code product page: Everyday Usage $5 a month, High Usage $15 at 5× the Everyday allowance, Power Usage $50 at 20×, Maximum Usage $200 at 80×. Power is the cheapest chair that includes Wonder Full. The allowances run on five-hour and weekly resets, and per the Terms, a subscription’s per-period allowance expires at the end of each period and does not roll over. On Maximum, when the allowance is gone, Meta’s documented way forward is to wait for the refresh.

    The credential is a leash

    The subscription applies to the API key Meta automatically connects during Muse Code CLI onboarding, and the subscriptions doc is explicit about the boundary: “This credential is for use with Muse Code only.” The Terms give the arrangement its legal name — a Coding Harness Subscription — and the same restriction: the connected key “may not be used to access the Services outside the coding harness or to circumvent your subscription’s usage limits or billing.”

    Any additional API keys you create under the same account are billed pay-as-you-go, per token. So one Meta account holds two different commercial relationships at once: a flat seat that works only inside one CLI, and metered keys that work anywhere except that they can never call the frontier model. Budget them as two products, because Meta does.

    The default is the decision

    Here is the trap, and it is set by a default. “Muse Code subscriptions default to Contributor mode. In Contributor mode, you get more usage from your plan in exchange for letting Meta use your content — the prompts, code, files, and context you send, plus the model responses you get back — to train future Meta models.”

    A careful buyer can still walk into it. Meta’s Model Designation Policy lists Muse Wonder and Muse Wonder Full as Standard Models — the tier whose use constitutes Standard Services, where content is not used for training. The same policy then overrides the list: “If you access the Services through a Coding Harness Subscription, you are considered to be using the Contributor Services by default regardless of which Meta Model you select.” Terms section 3.3 says the same. In Muse Code, Contributor mode is not a model name. It is a subscription setting, and it is on.

    Turning it off is one toggle: open /settings in Muse Code. The help page states what the toggle does and does not do: “Turning Contributor mode off changes how much usage you get from your plan. It doesn’t change which plan you’re on.” How much usage changes, Meta does not publish — no ratio, no prompt count, no price difference appears in the documents. The honest line for a budget is that the size of the privacy discount is undocumented.

    Meta’s own warning belongs in every seat-setup checklist, quoted exactly: “You must not submit sensitive, confidential, or personal information to the Discounted Services. If your use case involves processing personal information, please use Standard Services.” Accounts with Zero Data Retention cannot use Contributor mode at all — and ZDR itself is an organization-level enablement Meta’s sales team turns on for Model API accounts, not a toggle in the CLI, and it does not cover requests made with a personal account.

    The switch does not reach backward

    The off-switch is prospective. Terms section 3.3: a change to Standard applies “prospectively only; it would not apply to Content previously submitted to the Contributor Services, and Meta’s rights with respect to that Content under Section 6 will survive the change.” Everything a seat sent while the default was on stays under the training grant after you flip the setting.

    Section 6.1 adds the subtler pull: “Content previously submitted to the Standard Services becomes Content submitted to the Contributor Services if it is included in any request to the Contributor Services, whether directly or as context or background for your prompts or instructions.” One later Contributor-mode session that pulls an earlier, clean conversation in as context reclassifies that content.

    The commitments page softens the arrangement with a safeguard and then qualifies it: before using Discounted Services content to train models, Meta “takes steps designed to disassociate that Content from your Accounts” — but Meta may use the same content for “evaluation, safety, abuse, quality, and policy review” without first applying those steps. And section 6.1 acknowledges the output side: models trained on your content may produce outputs “similar or identical to your Content,” including for third parties.

    The API shelf is labeled honestly

    On the API, the same choice exists — as a separate model name, printed on the pricing page where a buyer can see it. Contributor mode “isn’t available for Muse Wonder on Model API.” For Spark it is a different SKU: muse-spark-1.3-contributor and muse-spark-1.2-contributor at $0.10 input, $0.002 cached, $0.20 output per million tokens, against standard Spark at $1.25 / $0.15 / $4.25 — capped at 150 requests per minute against 3,000 for the standard IDs. The Muse Code product page labels the two rows without euphemism: the Contributor row is “Used to improve our products”; the standard row is “Not used to improve our products.”

    That is the contrast the seat hides. On the API, training is a priced, named, rate-limited variant a buyer selects on purpose. In the subscription, it is the factory setting of the harness — and the model table’s “Standard Model” label will tell a skimming buyer exactly the wrong story about which arrangement they are in.

    The operator’s checklist

    Decide the data arrangement before the repository, not after the first session. A public demo and a confidential codebase can run through the same agent on the same afternoon; they require different settings, and the setting is per-subscription, not per-conversation.

    Turn Contributor mode off in /settings before any client code, customer data, or contract-confidential material enters the seat — remembering that the flip protects only what is sent afterward, and that earlier standard content follows it if it is ever pulled back in as context.

    Buy the seat for the seat’s work. Wonder Full is a genuinely frontier tool for a person at a keyboard, and it is not a component. Anything your own product must call belongs on the API, in Standard mode, on keys you budget per token.

    This desk tracks Meta’s platform as it changes; the full rate card and the contributor tier’s arithmetic are in Meta Model API Pricing & Limits, and every Meta piece hangs off the Meta AI desk hub. The short version to tape above the desk: the model in the seat is not the model on the shelf, and the seat’s most consequential setting is the one nobody remembers choosing.

  • Meta Model API Pricing & Limits: Wonder, Spark, and the Cheap Tier That Trains on You

    Meta Model API Pricing & Limits: Wonder, Spark, and the Cheap Tier That Trains on You

    From the Tygart Media Meta desk. Prices below are Meta’s published rates, verified against Meta’s own pricing documentation on October 13, 2026, and cross-checked against our account’s live catalog on October 19, 2026. This page is the desk’s drift-watch surface: when Meta moves a number, this page is where the change gets recorded, dated. Desk home: Meta AI, Run in the Open.

    Meta’s pricing has one genuinely simple story and one trap. The simple story: a flagship priced exactly at the market’s flagship rate, a workhorse priced like a workhorse, both with million-token context and no long-context surcharge. The trap is a third tier that costs about 95% less — because you’re paying with your data instead. Here is the whole map, with the trap labeled.

    The API tiers (per million tokens)

    Model Input Cached input Output Rate limits (per team)
    Muse Wonder $4.00 $0.20 $20.00 3,000 RPM / 4M TPM
    Muse Spark 1.3 / 1.2 / 1.1 (Standard) $1.25 $0.15 $4.25 3,000 RPM / 4M TPM
    Muse Spark Contributor $0.10 $0.002 $0.20 150 RPM / 3M TPM

    Wonder’s $4/$20 matches the going flagship rate dollar for dollar — Meta is not discounting its best model, it’s daring you to compare it. Spark at $1.25/$4.25 is the tier a working shop will actually live on: a quarter of the flagship’s input price and under a quarter of its output price, with the same 1M-token context window and the same rate limits. There is no long-context premium at any length, which quietly removes a whole category of surprise bill. Web-search grounding, if you use Meta’s built-in tool, is $2.50 per 1,000 queries on top.

    The rest of the catalog is priced like utilities: Muse Image generates at a flat $0.01 an image, Voice Transcribe runs $0.18 per audio hour with diarization, and the SAM 3.1 segmentation model is $2.50 per 1,000 images — all three confirmed in our own account census on October 14, 2026. Spark’s maximum output is 131,072 tokens; Wonder’s maximum output is not stated on the pages Meta publishes, and this page won’t guess it.

    The Contributor trap: cheap because it trains on you

    Read the Contributor tier’s price again: $0.10 in, $0.20 out. That is not a sale. Meta’s own pricing page is plain about the exchange — in Contributor mode, Meta may use your prompts and the model’s completions to improve and train its products. Your discount is paid in data. Standard mode, at the prices in the table above, is the mode where your content is not used for training.

    Our house rule, printed so our future selves can’t negotiate with it: Contributor tiers are for disposable experiments only — never for client work, never for unpublished material, never for anything you wouldn’t read aloud in Meta’s lobby. The arithmetic isn’t close. A shop that routes real work through Contributor to save $4 a million tokens is selling its clients’ material at a price it would never accept in a contract. And one more wrinkle worth knowing: Muse Code subscriptions default to Contributor mode unless you turn it off — so the trap is also a default, and defaults are where shops actually live.

    The Cursor split: Spark is in, Wonder is out

    If your shop runs Cursor, your Meta options today are exactly one model long. Muse Spark 1.3 is a first-class Cursor model — added September 8, 2026, about six days after the model itself shipped — at the same $1.25/$4.25 rates, with full access to Cursor’s agent tools, a 300k context window by default or the full 1M in Max Mode. Muse Wonder is not in Cursor at all: no model page, no changelog entry, no announced timeline, and Cursor’s official bring-your-own-key program covers five providers — Meta is not among them. The base-URL override workaround exists, but Cursor staff describe it as unsupported and partially broken, it applies globally while it’s on, and it can never bring you Wonder Full. Bottom line from a shop that checked: for Meta inside Cursor, run native Spark 1.3; for Wonder, use the API.

    Muse Code plans — reported, not verified by us

    Meta’s own terminal agent, Muse Code, is sold by subscription as an alternative to per-token billing. The plan structure is verified on Meta’s documentation: four tiers — Everyday, High, Power, Maximum — with Power and Maximum including Wonder Full, the stronger flagship variant that the API does not sell at any price. The dollar figures below come from secondary reproductions of Meta’s pages, and we label them reported because we have not paid one yet: Everyday $5/month, High $15/month (5×), Power $50/month (20×), Maximum $200/month (80×). When this shop runs Muse Code through a real sitting, this section gets rewritten from receipts. Until then, it stays labeled.

    What the numbers don’t tell you

    Two costs never appear on a pricing page. The first is token hunger: independent launch-week measurement found Wonder slower to first token than its rivals’ median and thirstier with output tokens, and in an agent loop — where a model may be called hundreds of times on one job — a thirsty model at a fair per-token price can still be the expensive seat. The second is your own switching cost, which Meta has unusually lowered: one key speaking OpenAI and Anthropic protocols means the harness you already run is the harness you evaluate with. Our proof of that, and the gotcha that came with it, is in The Meta Model API, As We Run It.

    Last verified: October 19, 2026. The desk’s catalog watch re-reads Meta’s model list daily; pricing drift gets recorded here with its date, the same discipline this site applies to Claude’s pricing.

  • The Meta Model API, As We Run It

    The Meta Model API, As We Run It

    From the Tygart Media Meta desk — our own API key, our own test envelope, our own receipts. Desk home: Meta AI, Run in the Open.

    Every vendor will sell you an API with a launch post. What a working shop needs is duller and more valuable: does it answer, does it finish real work, what does it cost to find out, and what stupid thing will eat your first afternoon? On October 14, 2026, we wired Meta’s Model API into our own tooling and ran it. Here is the whole story, including the part where we blamed the API for our own mistake.

    The setup: one key, stored like it matters

    Meta’s developer platform is dev.meta.ai. You make a key in the dashboard, you put it in a vault — ours lives in our credential store, injected into the process only at run time, never written to disk, never pasted into a chat. Billing rides a partner-controlled card with a hard $25 test envelope on it. That envelope is a deliberate choice: a new platform earns production trust in stages, and stage one is “prove it works for pocket change.”

    The first check cost nothing: list the models. Our key read Meta’s catalog clean — nine models, from Muse Wonder down to a segmentation model we still haven’t touched. A key that can read the catalog is a key that works; everything after that is about the work, not the wiring.

    The proof: a work-order-shaped task, 52 seconds

    We pointed OpenCode — an open-source terminal agent, version 1.19.0 — at Meta’s API as an OpenAI-compatible provider, and handed Muse Spark 1.3 the kind of job this shop hands every seat: a written spec (SPEC.md), from which it had to produce a working Python module (a slug utility) plus a pytest suite covering it. Not a riddle, not a benchmark — a small, real, verifiable unit of work with a pass/fail at the end.

    Spark 1.3 finished in about 52 seconds. Mid-run it discovered pytest wasn’t installed in its environment, provisioned its own virtual environment, installed what it needed, and ran its tests: 8 of 8 passing. Then we did what we do with every seat’s output, including our own: we didn’t take its word. We re-ran the suite ourselves, added five extra cases of our own, read the code line by line. All green, code clean. Total damage to the $25 envelope across the entire day’s probing of every text model on the account: under two cents.

    The gotcha: our first failure was not Meta’s

    The first attempt “failed.” Silently. No error, no output — the run simply never came back. The natural conclusion is that the shiny new API is broken. The actual cause: opencode run hangs forever when its standard input is left open in a non-terminal session. Run it with stdin closed — </dev/null — and it works perfectly. No API fault, no key fault; a harness quirk that cost us one debugging cycle and taught us, again, the oldest lesson in this shop: when a new platform “fails,” check your own plumbing before you write the platform off. We’re printing the gotcha in the desk’s first article on purpose. The next shop that wires this API deserves to skip our lost afternoon.

    One API, three dialects — and why a shop should care

    The most consequential thing about Meta’s API is not any single model. It’s that the same key speaks three protocols: OpenAI’s Chat Completions, OpenAI’s Responses API, and Anthropic’s Messages API. Meta’s own quickstart documents pointing Claude Code at api.meta.ai by changing a base URL, Codex at the Responses surface, and OpenCode at the OpenAI-compatible endpoint — all with the one key.

    For a shop, that collapses a real cost. Harnesses are habits: your prompts, your permissions, your work-order formats, your muscle memory. A model provider that demands a new harness taxes every one of those. A provider that plugs into the harness you already run lets you spend your evaluation budget on the only question that matters — is the model any good at your work? It’s also a discipline on the provider: when switching is cheap, the model has to win on merit every month, not on lock-in. We like platforms that volunteer for that test.

    Two quirks worth knowing before your first loop. Reasoning is mandatory on these models: settings like reasoning_effort: "none" come back as errors rather than being quietly ignored, so sloppy OpenAI drop-in code can fail loudly — better than silently, but plan for it. And reasoning tokens burn against your output cap, so set generous maximums; a tight cap buys you empty replies, as our census probes found out so yours don’t have to.

    What this does not prove — yet

    One 52-second task proves the route works and the model can finish a small job cleanly. It does not prove Wonder’s ceiling, anyone’s reliability across a month of autonomous loops, or behavior under production load — and this desk won’t claim otherwise. The head-to-head that would actually settle the seat question — Composer vs. Spark in Cursor vs. Wonder through this API, same work order, same scoring — is scheduled and unrun, and it’s named that way on the desk’s front page. When it runs, it lands here, numbers and all, whichever way it cuts.

    Prices, tiers, and the one discount that should make you read the fine print twice are on the desk’s pricing page: Meta Model API Pricing & Limits.