Meta's Muse Ember costs $0.10 per million input tokens and $0.50 per million output tokens for prompts up to 200K tokens, and the rates triple above that. Meta's own benchmarks put it level with Claude Haiku 5.5 on some tests and behind it on hard coding, and the API default is max reasoning effort, which is billed as output. Before you move traffic, test it on one bounded job from your iOS app's backend with 20 to 50 of your own cases, turn the token counts into a monthly cost, and route it behind validation with a fallback to your current model.
Meta released Muse Ember on November 9, 2026, and by the next day its announcement was near the top of Hacker News. The headline number is the price: $0.10 per million input tokens and $0.50 per million output tokens, with a 1M-token context window. Meta pitches it for repetitive agent work such as tool calls, coding subtasks, routing, extraction and long-document parsing.
If you run an iOS app with AI features, or you use coding agents on an iOS codebase, that price makes you look at your bill again. This post covers what Meta actually published, what the benchmark table can and can't tell you, and a way to test a small model on one of your own jobs in an afternoon before you move any traffic to it. The test scripts are below, and you can point them at any provider.
What Meta released
Here is what Meta's research post and API docs say, as of November 10:
- The model ID is
muse-ember-1.0. Meta calls it its smallest and most efficient model, and the first one trained using Muse Wonder Full. - For prompts up to 200K tokens, input costs $0.10 per million tokens, cached input $0.004 per million and output $0.50 per million. Above 200K tokens the rates triple to $0.30, $0.012 and $1.50.
- The context window is 1,048,576 tokens, and a response can run to 524,288 output tokens.
- Input can be text, images, video, audio and PDF. Output is text.
- The API docs list three endpoints: Responses, Chat Completions and Messages. Meta's developer blog says an OpenAI-style client needs only a
base_urlchange tohttps://api.meta.ai/v1. - Reasoning effort runs from
"minimal"to"max", and the docs give the default as"max". - It is available through the Meta Model API and Muse Code, where it is included in every plan, and Meta lists it on Google Cloud and Oracle Cloud as well.
Meta's suggested pairing is Ember for bounded, repeated work and a larger model (Muse Wonder or Muse Spark) for planning and hard reasoning. That split matters more than any single benchmark row, and most of this post is about deciding which of your jobs are bounded enough.
What the benchmark table tells you, and what it leaves out
Meta compares Ember with Claude Haiku 5.5 and GPT-6 Luna. On the Artificial Analysis Intelligence Index, Meta reports 36 for Ember, 36 for Haiku 5.5 and 28 for GPT-6 Luna. On Terminal-Bench 4.0 it reports 40.9% for Ember against 39.2% for Haiku 5.5. In Meta's cost table, Ember scores 35.8 at about $0.136 per task, while Haiku 5.5's best score of 36.2 costs $0.411 per task.
Four things in the same post should slow you down before you act on those numbers.
First, Ember does not win everywhere. On FrontierCode 2.0-AA Meta reports 27.2% for Ember and 34.9% for Haiku 5.5. If your workload looks like hard, open-ended coding, Meta's own table points away from Ember.
Second, Meta ran most of these evaluations itself, and some are labeled internal. Two charts use different cost bases: one caption says estimates at proposed pricing and another says list pricing.
Third, the scores are at max reasoning effort, which is also the API default. Reasoning tokens are billed as output, so a model left on max for a classification job can spend far more than the per-token price suggests. If you migrate and forget to set effort, your first invoice will show it. Max Reasoning Effort Costs Up to 42x More on Easy Tasks has the measurements behind that warning.
Fourth, the partner quotes (Box, Cloudflare, You.com, Cline, Oracle) come from early testing. They tell you who had access. They are not independent measurements.
None of this means the model is bad. It means a public leaderboard can't tell you how a model handles your crash logs, your App Review rejection emails or your screenshots. You find that out by running your own cases, and the cheaper the model, the cheaper that test is.
Where a small model fits in an iOS app
The jobs that suit a cheap model have three things in common. The answer is short, you can check it with code, and you run the job often. Some examples from a typical iOS app backend:
- Labeling incoming crash reports by likely cause before a person looks at them: memory pressure, watchdog timeout, a crash inside your own code or inside a third-party SDK.
- Summarizing App Store Connect review notes and TestFlight feedback into one line each for a weekly triage list.
- Pulling structured fields out of support emails: app version, device, iOS version, and whether the user mentions a purchase.
- Checking screenshots for obvious problems such as placeholder text, a debug banner or clipped labels before you upload a new set.
- Routing: deciding whether a user's request in your app needs the expensive model or can be answered by the small one.
On the coding side, Meta's own examples are subagent work: parallel code migration, reading many files to find call sites, and renaming across a codebase. If your agent setup already splits planning from execution, the execution half is the candidate.
Jobs that suit it less are the ones where a wrong answer is expensive and hard to spot: rewriting your StoreKit purchase flow, deciding how to answer a Guideline 2.1 rejection, or anything where the output goes straight to a user without a check. Keep a larger model there, or keep a person in the loop.
Two rules before any user data touches a new model
The first rule is about the API key. Never put a model provider's key inside your iOS app. Anything in the app bundle can be pulled out of it, and a leaked key lets anyone spend your money. Your app calls your own backend, the backend holds the key and calls the model, and the backend can also enforce per-user limits. If you already do this for another provider, swapping models is a server change and needs no app update.
The second rule is about Apple's guidelines. Guideline 5.1.2(i) says: "You must clearly disclose where personal data will be shared with third parties, including with third-party AI, and obtain explicit permission before doing so." Adding a new model provider means user content now goes to a new company. Check that your privacy policy, your in-app consent screen and your App Privacy answers in App Store Connect still describe what you do. Meta's API docs page doesn't state data retention or regions, so read the provider's terms before you send personal data, and don't assume they match the provider you use now.
Jobs that use no personal data, such as checking your own marketing screenshots or labeling crash reports that contain no user content, are the easiest place to start for exactly this reason.
Step 1: pick one job and write 20 to 50 cases
Choose a single job from the list above. Crash-report triage is a good first pick because the answer is one label and you already have history to draw on.
Write each case as one line of JSON with an input and the answer you expect. Take real examples from your own data, with personal details removed, and include the awkward ones: the report that mixes two causes, the one with a truncated stack, the one in another language. Twenty cases is enough to see a big difference. Fifty gives you more confidence when two models are close.
{"id": "c1", "input": "Termination Reason: JETSAM, memory limit exceeded", "expected": "out-of-memory"}
{"id": "c2", "input": "Exception Type: EXC_BAD_ACCESS in MyApp FeedViewModel.swift:88", "expected": "crash-in-our-code"}
{"id": "c3", "input": "Termination Reason: FRONTBOARD 0x8badf00d", "expected": "watchdog-timeout"}
Write down the expected label before you run anything. If you decide what counts as correct after you see the output, you'll grade the model on a curve without meaning to. Write your acceptance criteria before you prompt makes the same case for coding tasks.
Step 2: run the same cases against each model
The script below sends every case to a model through a Chat Completions endpoint, compares the reply with the expected label, and records tokens and time. It has a stub mode so you can check the harness before spending anything. I ran it in stub mode against the three cases above and it reported 1 of 3 correct, which is what the stub should produce. I did not run it against Meta's API, so treat the live branch as a starting point and check it against the provider's current reference.
"""Run one bounded job against a model and score it against your own cases.
cases.jsonl: one object per line, {"id": "...", "input": "...", "expected": "label"}
Usage:
STUB=1 python3 eval_small_model.py cases.jsonl # dry run, no API call
MODEL=muse-ember-1.0 BASE_URL=https://api.meta.ai/v1 \
API_KEY=... python3 eval_small_model.py cases.jsonl
"""
import json, os, sys, time
LABELS = ["crash-in-our-code", "crash-in-sdk", "out-of-memory", "watchdog-timeout", "unknown"]
SYSTEM = ("You triage iOS crash reports. Reply with exactly one label from this list "
"and nothing else: " + ", ".join(LABELS))
def call_model(text):
if os.environ.get("STUB"):
# Fake model for testing the harness itself.
guess = "out-of-memory" if "jetsam" in text.lower() else "unknown"
return guess, {"prompt_tokens": len(text) // 4, "completion_tokens": 3}
from openai import OpenAI
client = OpenAI(base_url=os.environ["BASE_URL"], api_key=os.environ["API_KEY"])
resp = client.chat.completions.create(
model=os.environ["MODEL"],
messages=[{"role": "system", "content": SYSTEM},
{"role": "user", "content": text}],
# Effort: check the exact field name in your provider's API reference.
# Keep it here, in one place, so every run uses the same setting.
extra_body=json.loads(os.environ.get("EXTRA_BODY", "{}")),
)
u = resp.usage
return resp.choices[0].message.content.strip(), {
"prompt_tokens": u.prompt_tokens, "completion_tokens": u.completion_tokens}
def main(path):
cases = [json.loads(l) for l in open(path) if l.strip()]
passed, tin, tout, rows = 0, 0, 0, []
for c in cases:
t0 = time.time()
got, usage = call_model(c["input"])
ok = got == c["expected"]
passed += ok
tin += usage["prompt_tokens"]; tout += usage["completion_tokens"]
rows.append({"id": c["id"], "expected": c["expected"], "got": got,
"ok": ok, "seconds": round(time.time() - t0, 2)})
for r in rows:
if not r["ok"]:
print(f"FAIL {r['id']}: expected {r['expected']}, got {r['got']!r}")
print(f"{passed}/{len(cases)} correct, {tin} input tokens, {tout} output tokens")
json.dump(rows, open("results.json", "w"), indent=2)
if __name__ == "__main__":
main(sys.argv[1])
Run it three ways for each model you compare: at the lowest effort, at a middle setting, and at max. Put the effort setting in EXTRA_BODY using the field name from the provider's API reference. Meta's blog warns that results vary from run to run, so run each setting at least twice and look at the cases that flip.
Two things to look for in the results. The first is format failures, where the model answers with a sentence instead of a label. Those are cheap to fix with a stricter prompt or structured output, which Meta lists as supported. The second is real misclassifications. Read every failure yourself. A model that gets 46 of 50 right but fails the four reports involving your payment SDK may be worse for you than one that gets 44 right with random misses.
Step 3: turn token counts into a monthly number
The harness gives you average input and output tokens per job. Multiply by your real volume to compare models in money rather than in benchmark points. This script uses Meta's listed rates and switches to the long-context rates when a prompt passes 200K tokens:
# Cost per 1,000 jobs at Muse Ember list rates (USD per million tokens, Meta, 9 Nov 2026).
# Edit the rates if Meta changes them.
RATES = {
"short": {"input": 0.10, "cached": 0.004, "output": 0.50}, # prompt up to 200K tokens
"long": {"input": 0.30, "cached": 0.012, "output": 1.50}, # prompt over 200K tokens
}
def job_cost(input_tokens, cached_tokens, output_tokens):
prompt = input_tokens + cached_tokens
r = RATES["long"] if prompt > 200_000 else RATES["short"]
return (input_tokens * r["input"]
+ cached_tokens * r["cached"]
+ output_tokens * r["output"]) / 1_000_000
if __name__ == "__main__":
# Fictional example jobs. Replace with token counts from your own logs.
jobs = {
"crash log triage": (6_000, 2_000, 400),
"review-note summary": (1_500, 1_000, 250),
"screenshot QA (1 image)": (3_000, 1_000, 600),
"300K-token log dump": (300_000, 0, 1_500),
}
for name, (i, c, o) in jobs.items():
print(f"{name:26s} ${job_cost(i, c, o)*1000:8.3f} per 1,000 jobs")
With those made-up token counts it prints about $0.81 per 1,000 crash-triage jobs, $0.28 per 1,000 review-note summaries, $0.60 per 1,000 screenshot checks and $92.25 per 1,000 jobs for the 300K-token log dump. The token counts are invented for the example. I don't know how many tokens Ember charges for one of your screenshots, so measure that from the usage numbers the API returns.
The last row is the one to remember. A 1M-token context window invites you to paste in everything, and the moment a prompt crosses 200K tokens every token in it costs three times as much. For log analysis, trim the input to the relevant window first. A small script that keeps the 200 lines around the crash usually beats sending the whole file.
Also count the output tokens at the effort level you actually plan to use. If your harness shows that max effort produces ten times the output tokens of low effort for the same accuracy, the cheap model at max can end up costing more than a pricier model at low. Measure it on your own cases.
Step 4: route with a fallback
When the small model passes your cases, don't switch everything at once. Put it behind a check:
- Send the job to the small model.
- Validate the reply with code. For a label job, check that the reply is exactly one of the allowed labels. For extraction, parse it as JSON against a schema and check required fields.
- If validation fails, retry once on the same model with the error included, then send the job to your current, larger model.
- Log which path each job took.
After a week, the log tells you the real fallback rate. If 3% of jobs fall back, your cost is roughly 97% small-model pricing plus 3% large-model pricing plus the wasted first attempt on those 3%. If 30% fall back, the job wasn't bounded enough and you should keep it on the larger model.
The same pattern works for in-app features. A support assistant can answer common questions with the small model and hand anything involving refunds, account deletion or purchases to the larger one, or to a person.
Work out the blended cost before you trust the saving
A fallback path changes the price per job, because a job that fails validation is paid for more than once: the first attempt, the retry, and then the larger model. Call the cost of one job on the small model S, the cost on your current model L, and the share of jobs that fall back f. The average cost per job is then:
blended = (1 - f) * S + f * (2 * S + L)
= S + f * (S + L)
This short script prints the result for a few fallback rates. It uses $0.81 per 1,000 jobs for the small model, the made-up crash-triage figure from Step 3, and $5.00 per 1,000 jobs for the current model. The $5.00 is an example value, so replace both numbers with what your harness measured.
# Blended cost per 1,000 jobs with one retry and a fallback.
S = 0.81 # small model, USD per 1,000 jobs (from your harness)
L = 5.00 # current model, USD per 1,000 jobs (example value)
for f in (0.0, 0.03, 0.10, 0.30, 0.50):
blended = S + f * (S + L)
print(f"{f:>4.0%} ${blended:5.2f} saves {1 - blended / L:5.1%}")
print(f"break-even fallback rate: {(L - S) / (L + S):.1%}")
Run with Python 3.12 on a Mac, it prints:
0% $ 0.81 saves 83.8%
3% $ 0.98 saves 80.3%
10% $ 1.39 saves 72.2%
30% $ 2.55 saves 48.9%
50% $ 3.72 saves 25.7%
break-even fallback rate: 72.1%
Two things stand out. With these numbers the small model still saves money at a 30% fallback rate, so cost alone would not tell you to stop. The reasons to stop are the ones a price table hides. Nearly a third of your requests wait for up to three model calls instead of one, and a job that fails validation that often is telling you the task is less bounded than you thought.
The second point is the break-even. The saving reaches zero when f = (L - S) / (L + S), which is about 72% here. The closer the two prices are, the lower that number falls. A model that is only a little cheaper than your current one has to pass validation almost every time to be worth the extra path, while a model that is ten times cheaper can afford a lot of misses on cost and still lose on waiting time.
What to log on every job
Step 4 says to log which path each job took. One line of JSON per job is enough, as long as it has the same fields every time. Log the IDs and the numbers, and leave the user's text out of it. That keeps the log small, and it means the log itself is not another copy of personal data that you have to disclose and protect.
{"ts": "2026-11-16T09:00:04Z", "job": "crash-triage", "id": "c3", "path": "retry", "valid": true, "in_tokens": 1290, "out_tokens": 21, "ms": 905}
Use three values for path: small when the first reply passed, retry when the second attempt on the small model passed, and fallback when the job went to the larger model. Add the token counts from every call the job made, because that total is what you pay for. The script below turns a week of those lines into the two numbers you need for the formula above, the retry rate and the fallback rate, plus a rough 95th percentile of response time per job type.
"""Summarize a routing log: one JSON object per line, as in the example above.
Usage: python3 fallback_report.py routing.jsonl
"""
import json
import sys
from collections import defaultdict
jobs = defaultdict(lambda: {"n": 0, "retry": 0, "fallback": 0, "ms": []})
for line in open(sys.argv[1]):
line = line.strip()
if not line:
continue
row = json.loads(line)
j = jobs[row["job"]]
j["n"] += 1
if row["path"] in ("retry", "fallback"):
j[row["path"]] += 1
j["ms"].append(row["ms"])
for name, j in sorted(jobs.items()):
ms = sorted(j["ms"])
slow = ms[int(0.95 * (len(ms) - 1))]
print(f"{name}: {j['n']} jobs, retry {j['retry'] / j['n']:.0%}, "
f"fallback {j['fallback'] / j['n']:.0%}, p95 {slow} ms")
On a six-line sample log with one retry and one fallback among five crash-triage jobs, it printed:
crash-triage: 5 jobs, retry 20%, fallback 20%, p95 905 ms
review-notes: 1 jobs, retry 0%, fallback 0%, p95 350 ms
Six lines prove only that the script runs. With a real week of traffic, read the fallback rate per job type and not as one average, because a single badly bounded job can hide behind several that pass every time. Watch the trend as well as the level. A rate that climbs from 3% to 8% over two weeks usually means your inputs changed, for example a new app version that writes crash reports in a different shape, and the cases you tested in Step 1 no longer cover what the model sees.
If you try it as a coding subagent
For coding work, Meta points to Muse Code, its coding agent, where Ember is included in every plan. Meta's developer blog shows a --yolo flag that approves the agent's shell commands without asking, and it warns that agents can read MODEL_API_KEY. Its advice is to run that mode only in a sample folder with a key you are comfortable giving to an agent. On an iOS repo, that rules out any folder where your signing certificates, App Store Connect API keys or .env files live.
If you already use another agent and want to try Ember for subagents, give it the narrow jobs first: find every call site of a deprecated API, rename a type across modules, update a set of snapshot tests after a design change. Check the diff and run your tests the same way you would for any agent output. A cheaper model doesn't change the review step.
A short checklist
- Pick one bounded job whose answer you can check with code.
- Write 20 to 50 cases from your own data, with expected answers written first.
- Run them at low, medium and max effort, at least twice each, on the new model and your current one.
- Convert tokens to a monthly cost at your real volume, and watch the 200K-token tier.
- Update your privacy disclosures before user data goes to a new provider (Guideline 5.1.2(i)).
- Keep the key on your server, and route with validation and a fallback.
- Review the fallback log after a week before moving the next job.
FAQ
Is Muse Ember better than Claude Haiku 5.5?
On Meta's own table it is close on the Intelligence Index (36 each), ahead on several agent benchmarks and behind on FrontierCode 2.0-AA. Most of those evaluations were run by Meta. Your own cases are the only comparison that answers the question for your app.
Can I call it directly from my iOS app?
You can technically, but you shouldn't. A key shipped in the app can be extracted. Call your own backend and keep the key there.
What is the default reasoning effort?
Meta's model page gives the range as "minimal" to "max" with "max" as the default. Set it explicitly for every job so your costs don't depend on a default that might change.
Does the 1M-token context window mean I can send whole log files?
You can, but prompts over 200K tokens are billed at three times the input and output rates. Trimming the input is usually cheaper and gives the model less noise to read.
Do I need to change anything in App Store Connect?
If personal data will go to a new third party, review your App Privacy answers and privacy policy, and make sure your in-app consent covers the new provider, as Guideline 5.1.2(i) requires.
How many fallbacks are too many?
On cost alone, the break-even is (L - S) / (L + S), where S and L are the cost per job on the small model and on your current one. Waiting time and a rising trend matter sooner than that number. If the fallback rate for a job keeps climbing from week to week, move that job back to the larger model and rewrite your test cases before you try again.
If you want a ready-made way to do the cost side of this, my Opus 5.5 Coding Workflow & Cost Kit includes an editable .xlsx token-cost calculator with manual rate inputs, plus templates for writing acceptance criteria and reviewing AI-generated code. It is built around the Claude API, but the rates are editable, so you can enter another provider's prices for a side-by-side estimate.
Keep reading on JR Devhub
- Revolut Says Self-Hosting Cut Its AI Coding Bill 90%. Run This Math Before You Copy It
- Ripple-65B vs Mistral Large 4: The Scores Don't Compare, So Test Both on Your Repo
- AI Coding Costs: Why Your Agent Bill Is Mostly Re-Reading (and 7 Ways to Cut It)
- Claude Fable 5.2 Is Out. What to Change in Claude Code and Your App's API Calls Before You Switch

Comments