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.

  • We Ran Muse Spark’s Reasoning Dial Through 52 Calls. The Cheapest Setting Never Lost.

    We Ran Muse Spark’s Reasoning Dial Through 52 Calls. The Cheapest Setting Never Lost.

    Every API model ships with a dial most people never touch. On Meta’s Muse Spark 1.3, the dial is called reasoning_effort — it decides how long the model thinks before it answers. Turn it up and you pay more tokens and wait longer, on the theory that more thinking means better answers.

    We spent two days testing that theory on the contributor tier of Muse Spark 1.3 — the same engine our own publishing fleet runs on. Fifty-two API calls, seven different kinds of work, every rung of the dial, everything scored against known ground truth. The result surprised us, and it changes how we run the fleet:

    The cheapest setting never lost. Not once. On hard tasks, the expensive settings mostly bought latency — and twice, extra thinking was the failure itself.

    How we got the dial wrong first

    During a hackathon last month we tried to set the dial with a parameter called reasoning. The API rejected it, and we wrote down “the API won’t let us control reasoning.” That was wrong — the parameter is reasoning_effort, and it works fine. Lesson one of testing a model: a rejection usually means you asked wrong, not that the door is locked.

    We also carried a second error into the test: a belief that the API capped output at 8,000 tokens. It doesn’t. That cap was our own router setting, repeated so often it hardened into “fact.” Generation verified past 15,000 tokens in a single call. Both errors are corrected in our own records now, with the receipts attached — which is the point of running a test like this in the open. The test’s first findings were about us.

    The ladder has six rungs — and one of them doesn’t exist

    The full map, settled by the API’s own error messages when we fed it bad values: minimal, low, medium, high, xhigh, max. That is the complete list.

    Two things people assume about this dial are false. There is no “extra high” setting — xhigh is that rung, and the spelled-out version is rejected. And there is no off switch you can use: none appears in the generic schema, but this model rejects it with a message that lists exactly what it does support. On Muse Spark 1.3 contributor, the model always thinks at least a little. The only question is how much you pay for.

    The rounds

    Every task was run at multiple settings with identical prompts, and scored mechanically — no vibes, no “this answer feels smarter.”

    Contradiction checking (a spec paragraph, 24 statements, name the ones that contradict it): exact answers at every setting. Low used about a third of the reasoning tokens of the default.

    A buyer-brief judgment task — the hardest test we built. Four vendor blurbs against six hard rules (billing terms, export fees, Saturday support, a $7,200 year-one cost cap, HIPAA, cancellation windows), with planted traps: one vendor breaks two rules with numbers you have to multiply out, one hides a disqualifier in its cancellation clause, one is clean only if you notice the free-months clause. Every rung — minimal through max, plus unset — produced the identical score: correct winner, all five real traps caught, zero missed. Minimal used 776 reasoning tokens and 6.5 seconds. Xhigh used 6,847 tokens and 50 seconds. Same answer.

    Agentic planning (schedule an 8-step pipeline with dependencies and resource constraints into parallel waves): provably optimal schedules at every rung. Minimal solved it in 242 reasoning tokens.

    Code debugging (a function with three planted bugs): every rung found the inverted discount logic and the rounding bug; the cheapest setting found all three.

    Verdicts at scale (120 claim records, check each against a two-part rule): 120 out of 120 correct at low — and 120 out of 120 at xhigh. (Our first scorer reported 83/120 at both settings; the bug was in our regex, not the model. We re-ran it with the full text saved, corrected the record, and retracted the number. Test harnesses fail too, and the honest write-up says so.)

    Constrained writing (a briefing paragraph with five required facts, three forbidden claims, and a word band): every rung delivered all five facts, zero forbidden claims, in band. Reasoning ranged from 729 tokens to 6,687. The paragraph didn’t get nine times better. It got nine times slower.

    Where more thinking actually hurt

    Twice in 52 calls, the expensive end of the dial was the failure:

    • Left unset, the model burned 7,578 reasoning tokens on the vendor task — more than any explicit setting — for the same score minimal got for 776. The default thinks hard whether you asked it to or not. Unset is not neutral; it’s the expensive option wearing a disguise.
    • On the debugging task, an xhigh call consumed its entire 8,000-token budget on reasoning — 7,998 reasoning tokens, completion exactly 8,000 — and returned an empty answer. It thought so long it never spoke. Minimal answered the same task correctly with 500 reasoning tokens. Anyone who has watched an agent stall mid-job has seen this shape; here it is with a meter on it.

    And one anomaly worth naming: max is the top rung by name, but on the vendor task it burned less than xhigh (3,773 vs 6,847). The rungs are task-shaped budgets, not fixed ceilings — max buys you permission to think longer, not a guarantee of the deepest burn.

    What it cost

    Fifty-two calls, roughly 31,000 tokens in and 145,000 out across both days: $0 charged. The contributor tier’s billing never touched the $25 test envelope we run it under, and its per-token price remains unpublished as far as we can verify — we won’t invent one. At the standard tier’s published rates ($1.25 per million in, $4.25 per million out), the entire test programme would have cost about 65 cents. The dial still matters at fleet scale: reasoning tokens bill as output, and a fleet that runs xhigh by habit pays roughly nine times the reasoning cost of one that runs low — for, on this evidence, the same answers.

    The operating rule we run now

    • Mechanical work — extraction, checking, verdicts, formatting: minimal or low.
    • Judgment work: low, stepping up to medium when the task deserves a second think.
    • Xhigh and max are earned, not default: a task graduates to them only after it has demonstrably failed at low. In 52 calls across seven kinds of work, no task has earned it yet.
    • Never leave the dial unset. The default is the high band with none of the intent.

    The honest limits of this test

    One sample per cell. Seven task classes, all of them the kind of work a publishing fleet actually does — checking, judging against a brief, planning, debugging, classifying at scale, writing to constraints. We did not test open-ended research, long creative writing, or mathematics, and a task in those families might break the pattern; the battery is built to be re-run the day one appears. Reasoning-token counts also vary between sessions on identical tasks — sometimes by ~30% — so treat the exact numbers as readings, not constants.

    But the shape of the result is hard to argue with: on real operational work, this model’s floor is high, and the dial mostly prices your patience. If your fleet — agent, workflow, whatever you run — has a reasoning setting you’ve never touched, the test is cheap, the scoring is easy to make mechanical, and the answer might save you nine-tenths of your reasoning bill. Run the test. Publish what you find. We just did.

    Method and receipts: 52 calls to muse-spark-1.3-contributor via Meta’s Model API, November 6–7, 2026. Full findings, prompts, ground truth, and raw results: part of the Tygart-OS fact-gated fleet record on GitHub (github.com/TygartMedia/tygart-os-fact-gated-fleet). Errors found in our own earlier assumptions (the reasoning parameter name, the phantom 8,000-token cap, and one scorer bug) are documented in the same record, corrected where they stood.

    Counter-check, November 7, 2026: a reader sent us CursorBench’s rung-by-rung ladder for this same model, and on sustained coding-agent work the dial pays at every rung — the opposite slope from ours. Both numbers are real; the tasks aren’t the same. We worked through it here: The Coding Ladder Says the Dial Pays. Our 52 Calls Said It Didn’t. Both Numbers Are Real.

  • The Shared Brain: A Company Brain Any Model Can Read

    The Shared Brain: A Company Brain Any Model Can Read

    Nobody Sells a Shared Brain: Own Your Files, Swap Any Model, Make Every Job Teach the Next One

    Over the last few weeks, we set out to answer a question contractors, field operators, and growing businesses keep asking: does anyone actually sell an AI “shared brain”?

    We wanted three things. First, a central company knowledge base holding our standard operating procedures, pricing schedules, safety protocols, and drying standards. Second, AI agents our whole team can query in plain language from a phone or desk. Third, an automated loop that takes the reality of every finished job—walkthrough videos, moisture logs, readings, photos, and voice notes—and distils lessons back into that knowledge base so the company gets smarter every week.

    We spent weeks auditing vendor documentation, testing APIs, and checking rate cards. The short answer: nobody sells the whole system.

    Meta, Google, Microsoft, OpenAI, and Anthropic each sell pieces of the puzzle, but none sells the complete loop. Even worse, each suite keeps your knowledge inside its own walls. Gemini answers from Google Drive. Copilot queries SharePoint and Microsoft Graph. ChatGPT and Claude work best when you upload files into their proprietary Projects.

    If you build inside a vendor’s closed project, you haven’t built an asset you own. You’ve rented space in someone else’s walled garden. When that vendor changes pricing, alters terms, or falls behind a rival model, your architecture breaks.

    The design that survives vendor churn is deliberately boring: keep your source files in a standard folder tree you own, run a lightweight distillation loop across any model API, and treat chat interfaces as porches that plug in and out. If your files live in ordinary formats on storage you control, you can swap models in fifteen minutes by changing one line in a script. The files, lessons, and team habits never move.

    Contractor Knowledge Architecture • $0 to $20 DIY Setup

    Install The Shared Brain in Your Shop: Free, $7 & $17 Downloads

    Field-tested 4-folder setup checklists, conflicting price-sheet resolvers, truck visor habit cards, 20-question NotebookLM reader test logs, weekly distiller worksheets, and bot-ready AI operator routines built directly from this guide.

    Quick Reference
    FREE

    Shared Brain Quick Card

    2-page field card: The 4-folder tree (00-BRAIN / 10-JOBS / 90-HOPPER / 99-ARCHIVE), the porch-vs-warehouse rule (WhatsApp limits), and the truck field habit on one card — condensed from the starter and field-proof sections.

    Download Free PDF

    Direct download • No email gate

    Working Pack
    $7

    30-Day Starter Pack: Checklists & Logs

    Printable/fillable 6-page working pack: 4-folder setup checklist with conflicting price-sheet resolver, 15-to-20 canonical docs inventory (80% answer test), NotebookLM 20-questions reader test log, truck visor habit card, weekly distiller worksheet with Friday review log, and porch-vs-warehouse reference with seat math.

    Get Starter Pack ($7) →

    Instant checkout • Square verified

    AI Intensive
    Book for Bots
    $17

    The Shared Brain Operator

    Feed to ChatGPT, Claude, or Gemini: 8-page executable prompt playbook with 6 interactive AI routines (Muse Mix-Up Decoder, Seat Bleed Audit, Folder Tree Builder & Conflict Resolver, Reader Test & Gap Hunter, Field Habit Installer, Weekly Distiller & Grace-Rule Approver) plus embedded router.

    Get Bot-Ready Operator ($17) →

    Software made of words • Instant delivery

    Meta, Untangled: Three Products and One Name

    Much of the current confusion comes from Meta using the name “Muse” for three completely different offerings with three distinct price lists. Mixing them up will mis-budget your project from day one.

    First is the Meta Muse app. Per Meta’s help pages, Muse is strictly a personal AI agent tied to individual Meta accounts, not a team platform. Meta offers a free tier with an unpublished usage limit, alongside two paid tiers: Power at $20 a month for 500 million Muse tokens a week, and Maximum at $100 a month for 3 billion tokens a week. These subscriptions buy additional usage rather than extra business features. Meta describes zero team seats, zero shared workspaces, zero admin consoles, and zero central billing. Knowledge in the Muse app lives in an isolated virtual machine for one person. It cannot serve as a company brain; at most, it is an owner’s personal chief of staff.

    Second is Meta Business Agent. Rolled out globally in June 2026, this is a customer porch running on WhatsApp, Messenger, and Instagram. It handles inbound inquiries, qualifies leads, recommends catalog items, and hands off to human staff. Per industry reporting on Meta’s pricing documentation, Platform usage is listed at $2.00 per million tokens starting August 2026—roughly 4 to 5 cents per message exchange. Verify in your Meta console before budgeting.

    Meta also sells in-app access via Meta One tiers, from Essential at $14.99 a month to Max at $499 a month per WhatsApp profile. The subscription price is published; the response volume per tier is not, so cost per conversation cannot be modelled. Furthermore, Business Agent carries a critical boundary: uploaded files have no update call. If you upload a revised policy without deleting the older file, the agent draws on both documents simultaneously and can quote obsolete terms to customers.

    Third is the Meta Model API at dev.meta.ai, offering raw developer access to frontier models like Muse Wonder and multimodal workhorses like Muse Spark 1.3 Standard. On that Standard tier, pricing is listed at $1.25 per million input tokens and $4.25 per million output tokens, under strict terms stating data is not used to train Meta’s models. This is infrastructure you can build on, but it is raw API access, not turnkey software.

    Seats Are the Real Bill, Not Tokens

    When owners evaluate AI, they usually fear token consumption. They assume processing text, audio, and video will create runaway invoices. The reality is the opposite: token usage is a rounding error, while seat licenses dominate the monthly software bill.

    Consider the math for a 10-person restoration company running 20 jobs a month. If technicians record a 45-minute audio walkthrough and voice note on every job, transcribing all 900 minutes using a dedicated speech-to-text API costs under $3 a month. Feeding those transcripts, drying logs, and photos into a multimodal model like Muse Spark Standard to extract lessons costs roughly $0.29 per job—about $6 a month. Even stepping up to a frontier model like Muse Wonder at roughly $1.00 per job, monthly distillation totals just $20. The entire automated distillation loop runs for $10 to $30 a month in compute.

    The real financial bleed happens when companies stack overlapping user seats. Paying $20 or $25 per user each month for ChatGPT Business or Claude Team on top of an existing corporate email suite burns $200 to $250 a month for 10 users, and still leaves you with project file caps or isolated document silos.

    If your company already pays for Google Workspace Standard, team AI is effectively bundled at roughly $140 a month all-in for 10 users, with Gemini and NotebookLM included. If you run a Microsoft shop, the Business Standard plus Copilot bundle runs approximately $235 a month all-in for 10 people. Don’t pay for a second $200 seat subscription on top of a suite you already license; use what you have as the reading interface, and keep the master brain in your own folder tree.

    WhatsApp Is a Porch, Not a Warehouse

    Because field crews live inside WhatsApp, owners naturally ask whether they can turn a company WhatsApp group into the knowledge base. The platform’s technical limits and legal terms rule that out.

    First, WhatsApp enforces hard media file caps: videos are capped at 16 MB and images at 5 MB. A three-minute high-definition walkthrough shot on a smartphone easily runs between 100 MB and 1 GB. If a technician sends raw job walkthroughs through WhatsApp, the media is heavily compressed or blocked entirely.

    Second, WhatsApp Business terms updated in January 2026 expressly prohibit general-purpose AI assistants, while permitting bots scoped to a company’s own customer support. Moreover, the WhatsApp Business Platform operates strictly in one-to-one chats; group chats do not synchronize to the API.

    The rule for field operations is clear: WhatsApp is a front porch, never a warehouse. Customer conversations and quick field notifications can pass through WhatsApp, but raw media—walkthrough videos, moisture readings, and photo logs—must upload directly to the job folder in your cloud storage. WhatsApp carries the notification link; your owned folder stores the truth.

    Field Proof and the Grace Rule

    We did not invent the principle that structured capture must precede AI. One early field example to watch is TRUERESTORE’s Ripple platform, described as launched in October 2026.

    Ripple places an AI project coordinator directly inside every job file. It operates over moisture logs, drying equipment readings, LiDAR room scans, 360 photos, and technician notes. It automatically flags missing documentation before a crew leaves a site and drafts loss summaries for adjusters. Most importantly, Ripple follows a strict operational rule: it changes nothing in the job record until a human confirms.

    In our view, platforms like TRUERESTORE represent the chef’s kitchen. If an operator wants a fully managed, turnkey commercial solution tailored to restoration workflows, hiring the chef and buying into a proven platform is a smart decision. But if you want to cook your own dinner—to retain sovereign ownership over your files, prevent vendor lock-in, and build systems that adapt whenever new models arrive—the open, DIY architecture gives you that control. Both choices are valid. What fails every time is buying AI tools before establishing disciplined field capture habits.

    As case studies from ATI Restoration, Ascendum, and regional contractors show, companies that clean up per-job documentation see immediate operational payback. Companies that dump unorganized photos into AI bots simply automate chaos.

    Contractor Field Operating Toolkit

    Stop Automating Chaos: Install Clean Field Capture Habits & Sovereign Knowledge Governance

    As case studies from ATI Restoration, Ascendum, and regional contractors demonstrate, companies that clean up per-job documentation see immediate operational payback; dumping unorganized photos into AI bots simply automates chaos. Platforms like TRUERESTORE Ripple follow the strict Grace Rule: change nothing in company records until a human confirms. Whether you need printable checklists, conflicting price-sheet resolvers, and truck visor habit cards for your technicians, or an autonomous AI operator that audits duplicate software seats, stress-tests your SOPs against 20 crew questions, and distills weekly walkthroughs into approved one-page lessons, equip your shop with field-proven operating tools.

    ⚙

    What’s In The Field Toolkit:

    • 4-Folder Tree Setup: 00/10/90/99 structure & rules.
    • Price-Sheet Resolver: Kill duplicate rate sheets.
    • 15–20 Canonical Docs: The 80% answer test sheet.
    • NotebookLM Reader Log: 20 crew questions & gaps doc.
    • Truck Visor Card: Continuous video & 3-min audio.
    • Weekly Distiller Sheet: Situation / Action / Result / Rule.
    • Porch & Seat Math: WhatsApp caps & seat audit sheet.
    Sovereign Guarantee: Files live in ordinary formats you own. Swap any AI model in 15 minutes.

    The 30-Day Starter ($0 to $20)

    You do not need an enterprise software contract or an expensive consultant to start building a company brain. A small company can deploy a functional version in 30 days for between $0 and $20 in month one.

    Week 1 establishes the folder tree ($0). In whatever cloud storage you already use—Google Drive, Dropbox, OneDrive, or a local server—set up four root directories: 00-BRAIN for canonical company knowledge, 10-JOBS partitioned by year and job ID, 90-HOPPER for unreviewed field uploads, and 99-ARCHIVE for superseded policies. Populate 00-BRAIN with the 15 to 20 documents that already answer 80% of routine questions. If two conflicting price sheets exist, resolve them now.

    Week 2 activates the reader ($0). Create a free NotebookLM notebook titled “Company Brain” using the documents in 00-BRAIN as sources. Share it with your technicians and office staff in chat-only mode. Because NotebookLM quotes only from supplied sources and provides passage citations, it cuts fabrication — but it can still misquote or miss, so test before you trust. Test it against the 20 questions your crew asks most often, and log missing information into a gaps document.

    Week 3 establishes the field habit ($0). Tape a single-page procedure inside every service truck: after each walkthrough, the lead tech shoots a continuous video and records a three-minute voice note explaining what was found, what actions were taken, and what should be done differently next time. The media uploads directly into 90-HOPPER via the mobile storage app—never through WhatsApp. In the afternoon, the office moves reviewed job logs into 10-JOBS.

    Week 4 introduces the distiller ($0 to $20). Designate one person—an office manager or senior estimator—using the single $20 chat seat you already pay for or a funded API balance. Using a standardized prompt template, the distiller runs weekly job transcripts to generate candidate operational lessons formatted as: situation encountered, action taken, result, and rule for next time. Every Friday, the owner and distiller spend 30 minutes reviewing candidate lessons. Approved one-pagers move into 00-BRAIN; outdated versions are dated and moved into 99-ARCHIVE. That weekly 30-minute human review is the brain. The AI only proposes; humans decide what becomes company policy.

    Implementation Comparison

    Compare the Three Shared Brain Implementation Tiers

    Downloads only, built directly from the published substance of this guide — zero consulting fees, zero enterprise lock-in.

    Quick Reference

    Shared Brain Quick Card

    FREE

    • 4-Folder Tree Map: Root architecture (00/10/90/99) for existing cloud storage.
    • Porch-vs-Warehouse Law: WhatsApp 16MB/5MB limits & mobile app upload rule.
    • Truck Visor Procedure: Continuous video & 3-minute voice note structure.
    • 30-Day Starter Roadmap: Week 1–4 milestone progression ($0 to $20).
    • Grace Rule Reference: Human-in-the-loop policy review principle.
    Download Free PDF

    Direct download • No email gate

    Print-and-Use Pack

    30-Day Starter Pack (PDF)

    $7

    • 4-Folder Setup Checklist: Permissions, file types & directory paths.
    • Price-Sheet Resolver: Audit & reconcile duplicate SOPs & rate cards.
    • Canonical Docs Inventory: 20-doc tracker with 80% answer test pass gate.
    • NotebookLM Test Log: 20 most-asked crew questions benchmark & gaps log.
    • Truck Visor Field Card: Laminated 1-page cabin habit procedure.
    • Weekly Distiller Sheet: Situation / Action / Result / Rule worksheet.
    • Friday Review Log: Approve-to-00-BRAIN / Archive-to-99 audit log.
    • Porch & Seat Math Sheet: WhatsApp caps, Meta chooser & seat bleed audit.
    Get Starter Pack ($7) →

    Print-and-use • Instant delivery

    AI Intensive
    Book for Bots

    The Shared Brain Operator

    $17

    • Buyer Onboarding: Feed directly to ChatGPT, Claude, or Gemini.
    • /muse-decoder: Interactive diagnostic mapping to App vs Agent vs API.
    • /seat-audit: Kill double $200 AI seat stack; model $140/$235 bundles.
    • /folder-builder: Build 00/10/90/99 tree & reconcile duplicate SOPs.
    • /reader-audit: Run 20-questions benchmark & generate gaps report.
    • /truck-habit: Generate visor cards, upload guides & porch scripts.
    • /distiller: Ingest transcripts, output candidate lesson one-pagers.
    • Embedded Router: Universal multi-format command dispatcher.
    Get Bot-Ready Operator ($17) →

    Software made of words • Instant delivery

    Building in Public

    We are developing this entire architecture in public as part of the Meta hackathon build. The complete operational playbook—a practical playbook for owners that any restoration firm or trade contractor can implement—will be open-sourced on GitHub with no paywalls or gated access.

    As part of our commitment to transparent lineage, we are releasing the complete, un-redacted Research Brief behind this project as a free download. The brief contains the full model pricing tables, platform cap comparisons, architecture diagrams, and field gotchas. There is no email wall, no form to fill out, and no marketing capture.

    Free Research Brief Download (No Email Required)

    Read the complete findings, platform cost models, technical gotchas, and architectural blueprints in the free PDF.

    Download The Shared Brain — Research Brief (PDF)

    — Will Tygart, Tygart Media

    Want help installing this in your shop? Contact Tygart Media — the brief above stays free either way.

    Updated October 30, 2026 — corrected the seat-cost math and starter budget figures; softened claims the page could not support.

    Updated Nov 1, 2026 — added the free shared brain quick card, 30-day starter pack, and shared brain operator downloads to this guide.

  • Free Until You’re the Store: What Muse Spark Open’s License Actually Says

    Free Until You’re the Store: What Muse Spark Open’s License Actually Says

    I read licenses the way I read scopes of work: looking for the one line that changes the price later. Muse Spark Open’s license has two of those lines, and the internet is already getting both of them slightly wrong.

    So here’s the plain version, from the license itself — the Muse Model License Meta published with the Muse Spark Open weights on October 15, 2026.

    First, what the license gives you. It grants the model free of charge, and the list of rights is long: use it, copy it, modify it, fine-tune it, distill it, merge it, publish it, distribute it, sublicense it, and sell copies of it. That is a real grant. Most developers, including commercial ones, can build on this model for free.

    Now the famous line: twenty million dollars. Read it carefully, because it does not say what the headlines say it says.

    The clause does not trigger when a company gets big. It triggers when two things are true at the same time. One: you or your affiliates are in the business of giving third parties access to AI models as a product or service, through an API or something like one — the license calls that “Model as a Service.” Two: your whole group’s gross revenue passes twenty million dollars in some consecutive twelve-month stretch. If both are true, you have to notify Meta and sign a separate written agreement before you offer this model, or anything derived from it, through that service.

    In plain terms: the line is not drawn around companies. It’s drawn around a kind of store. If you’re selling raw access to the model by the API call, and you’re doing it at real scale, Meta wants a signature. Everybody else keeps walking.

    The license says so itself, in the same paragraph. The clause does not apply to internal use. It does not apply to research. It does not apply to any commercial activity that isn’t model-as-a-service. And it does not apply to using the model as a component that powers features of your own product. A fifty-million-dollar company running this model inside its own software owes Meta nothing under that clause. A company half its size reselling API access owes a phone call.

    I run Tygart Media. We are nowhere near twenty million in revenue, and we are not in the business of selling anybody API access to anything. So the clause doesn’t bind us — on either prong. I’m building an open-source shared-brain system on Meta’s models for the hackathon: a book and a tool any small company can take, plug into a folder of its own files, and run. Nothing in that is a model-as-a-service. The twenty-million line is a fence around a field I’m not standing in.

    What would change if I ever were? Two things would have to happen, not one. We’d have to start selling access to the model itself — our own hosted API that other people pay to call — and the whole company’s gross revenue would have to cross twenty million in a rolling twelve months. Then, before offering Muse Spark Open through that service, we’d notify Meta and sign their separate agreement. Growth alone never trips it. Reselling access alone, at small scale, doesn’t trip it either. It takes the store and the size together.

    The second line is smaller, and it’s the one that actually applies to small builders: the credit. Any product or service that uses the open weights — or a derivative of them — has to prominently display the words “Built with Muse Spark Open.” In the interface, or in the documentation, or on the website, or in the settings menu. Exact words. No revenue threshold on this one. A one-person shop owes the same line as everyone else.

    And “derivative” is defined broadly enough to deserve a second read. It covers any model created, trained, fine-tuned, distilled, or otherwise improved using the model — or using its outputs. Train a smaller model on what Spark Open wrote, and that smaller model is a derivative. The credit travels with it, and so does the usage policy. That’s not a trap; it’s just a term you should know before you distill anything.

    One more clause worth knowing, because it settles a question every builder asks: Meta claims no ownership of outputs generated by the model. What it writes for you is not Meta’s property under this license. The words are yours to publish, sell, or give away.

    Now the honest fine print about my own build, because this is where people will get sloppy. The license I’ve been quoting governs the downloadable open weights — the Software, in its words. My shared-brain build doesn’t ship those weights. It calls muse-spark-1.3 through Meta’s hosted API, which runs under Meta’s API terms, a different document. So the notice and the twenty-million clause don’t legally attach to my repo through this license at all. I’m putting the credit line in the README anyway, because the build stands on Meta’s models and saying so costs me nothing — but I’m labeling it as what it is: a credit I chose, not a term I tripped.

    That’s the whole shape of it. Free to use, free to build on, free to sell what you build — with a credit line on anything built from the weights, a usage policy that travels with every copy, and one revenue clause aimed squarely at the people reselling the model itself at scale. For a small shop, this license is not a catch. It’s a receipt that says the big door is open, and the only door with a lock on it is the one where you become the store.

    Read the license before you build. Then build.

    — Will Tygart, Tygart Media

    Built with Muse Spark Open — a credit we carry by choice for this build; see the license map for what the term itself requires and of whom.

    Sources: Muse Model License (version: Muse Spark Open, October 15, 2026), published on Meta’s model repo: https://huggingface.co/meta-models/Muse-Spark-Open-816B-A42B — opening grant; §1 (license travels with copies); §2 (notice + Derivatives definition); §3 (Model as a Service / $20M); §4 (no ownership of outputs); Exhibit A (Usage Policy).

  • 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 November 5, 2026, and cross-checked against our account’s live catalog on November 5, 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: November 5, 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.