Ten Cents, Three Cliffs

TL;DR.

Meta released Muse Ember on November 9 at $0.10 per million input tokens and $0.50 per million output. That is the same sticker as Claude Haiku 5.5 and GPT-6 Luna. Three companies now sell a small agent model at the same price, and Meta pitches Ember at exactly the work a router sends to the cheap tier: tool calls, coding subtasks, routing, extraction and long-document parsing.

Same sticker isn't the same bill. The three differ in two places the headline rate hides: where the long-context line sits, and what a cache hit costs.

• Three cliffs. Over the line, the whole request bills at a higher rate. Haiku 5.5's line is 100K tokens at 5x. Ember's is 200K at 3x. Luna's is 272K at 2x input and 1.5x output. A 150K-token document costs $0.0165 on Ember or Luna and $0.0825 on Haiku 5.5.
• The cheapest cache read on the market. Ember bills cached input at $0.004 per million, against $0.01 for Haiku 5.5 and Luna. On a cache-heavy sub-agent turn that's about 32% less per turn.
• A 40-turn agent session that grows to 215K tokens costs $0.070 on Ember, $0.092 on Luna and $0.338 on Haiku 5.5 in our model. Compact the context at 95K and the gap shrinks to $0.059 against $0.080.
• No model wins every column. On Meta's own table, Ember leads AutomationBench-AA by 24 points over Haiku 5.5 and trails it by 7.7 points on FrontierCode 2.0. That's an argument for routing by task inside the cheap tier, not for picking one.

Below: the rate card, three charts, a test plan, and cliffcheck.py, 60 lines that price your own request shapes on all three.

Prices are list prices from Meta, Anthropic and OpenAI as of November 11, 2026. Benchmark figures are as published by Meta and Artificial Analysis. Every request shape and session in this post is an illustrative assumption, not Nadir customer data.

The $0.10 rate card.

Three things to know before you read anything else into the table:

• All three bill the whole request at the long rate once the prompt crosses the line, not just the tokens above it. That's what turns a line into a cliff. We covered each of these lines when they shipped: Haiku 5.5's 100K cliff and the 272K line on OpenAI models.
• Meta doesn't list a cache-write price for Ember. We price writes at the plain input rate. If Meta bills a premium, Ember's agent numbers below move toward Luna's.
• Ember is on Meta's Model API, Muse Code, Google Cloud and Oracle Cloud, and supports the Responses API, with a 1M-token context and up to 512K output tokens. Meta hasn't said the weights are open.

Three cliffs.

Under 100K tokens, the three models are price-identical on uncached work. A 3K-token ticket classification costs $0.0004 on any of them. A 60K-token contract extraction costs $0.007 on any of them. If that's your traffic, choose on quality and latency and ignore the rest of this section.

Past 100K the order changes twice:

Meta lists long-document parsing as a core use for Ember, and between 100K and 200K it's 5x cheaper than Haiku 5.5. Between 200K and 272K, Luna is the only one of the three still on its short rate, and it's 3x cheaper than Ember. The cheapest model depends on the length of the request in front of you, which is a per-request decision, not a vendor choice.

The agent session.

Cheap models get most of their volume as sub-agents, and sub-agent sessions grow. Take one that starts with a 20K cached prefix of system prompt and tools, appends 5K tokens a turn of tool results and history, and writes 1K tokens a turn. By turn 40 its context is about 215K tokens.

• Haiku 5.5 crosses its 100K line at turn 18 and pays 5x on every turn after. Session: $0.338.
• GPT-6 Luna never crosses 272K. Session: $0.092.
• Muse Ember crosses 200K only on the last three turns, and its cache reads cost 60% less than the other two throughout. Session: $0.070.

At a million sessions a month, that's about $70,000 on Ember, $92,000 on Luna and $338,000 on Haiku 5.5, for the same sticker price. The single biggest fix isn't switching vendors. Compacting the context to 30K whenever it passes 95K, including the cost of the summary call, brings Haiku 5.5 and Luna to $0.080 and Ember to $0.059. Compaction has its own cost in cache rebuilds, which we priced in the compaction tax.

The per-turn view says where Ember's edge comes from. A turn that reads 80K cached tokens, writes 5K new ones and outputs 1K costs $0.00132 on Ember and $0.00193 on the other two. Most of that gap is the cache read. The rest depends on our cache-write assumption.

No one wins every column.

Meta's launch table puts Ember ahead of Haiku 5.5 on workflow automation (37.8% against 13.9% on AutomationBench-AA), roughly level on terminal work (40.9% against 39.2%), and behind on code generation (27.2% against 34.9% on FrontierCode 2.0-AA). On Artificial Analysis's Intelligence Index, Ember and Haiku 5.5 both score 36 at max effort, and Luna 28.

The cost-per-task number is the more interesting one. Artificial Analysis estimates Ember at max effort at about $0.136 per index task, against $0.411 for Haiku 5.5 at max, for nearly the same score. Same per-token price, a third of the cost per task, because Ember spends fewer tokens getting there. You.com, an early tester, reported 36% to 48% fewer output tokens on its own workload. That's a vendor-reported partner claim, but it points the same way.

Read the table with the usual caveats. Several benchmarks are Meta-internal. Terminal-Bench compares each model in its own best published harness. OSWorld 2.1 is scored with partial credit, and the binary scores are much lower (33.8%, 27.8% and 17.0%). And every number is at max effort, which isn't the default and isn't what you'd run on a classification call.

What the table does support: within the $0.10 tier, the right model depends on the task. Ember for tool-heavy automation and long parsing, Haiku 5.5 for code edits that stay under 100K, Luna for the 200K to 272K band. That's the same argument we made for routing between frontier models, one tier down.

Tutorial: cliffcheck.py.

cliffcheck.py prices request shapes and agent sessions on all three models, cliffs and cache rates included. Replace SHAPES with the token counts from your own logs: input, cache reads, cache writes and output per request, or the p50 and p95 of each.

"""cliffcheck.py: three models at $0.10/$0.50, priced on your own request shapes.

Muse Ember, Claude Haiku 5.5 and GPT-6 Luna share a sticker price. They differ on
where the long-context line sits, what a cache hit costs, and what a cache write costs.
Rates are list prices as of November 11, 2026, $ per million tokens.
"""
# name: (line, short rates, long rates); rates = (input, cache_write, cache_read, output)
# Over the line, the whole request bills at the long rate.
MODELS = {
    "Muse Ember":  (200_000, (0.10, 0.10,  0.004, 0.50), (0.30, 0.30,  0.012, 1.50)),
    "Haiku 5.5":   (100_000, (0.10, 0.125, 0.010, 0.50), (0.50, 0.625, 0.050, 2.50)),
    "GPT-6 Luna":  (272_000, (0.10, 0.125, 0.010, 0.50), (0.20, 0.25,  0.020, 0.75)),
}


def request_cost(model, fresh=0, write=0, read=0, out=0):
    """One request. fresh = uncached input, write = newly cached, read = cache hits."""
    line, short, long_ = MODELS[model]
    rate = long_ if fresh + write + read > line else short
    i, w, r, o = rate
    return (fresh * i + write * w + read * r + out * o) / 1e6


def session_cost(model, prefix=20_000, grow=5_000, out=1_000, turns=40, compact_at=None, keep=30_000):
    """An agent session: cached prefix, each turn appends `grow` tokens and writes `out`.
    compact_at: summarize the context back to `keep` tokens once it passes this size."""
    total, ctx = request_cost(model, write=prefix, out=out), prefix
    for _ in range(turns - 1):
        if compact_at and ctx + grow > compact_at:
            total += request_cost(model, read=ctx, out=2_000)       # the summary call
            total += request_cost(model, write=keep, out=0)         # re-cache the short context
            ctx = keep
        total += request_cost(model, read=ctx, write=grow, out=out)
        ctx += grow
    return total


SHAPES = {  # name: kwargs to request_cost (one request) -- illustrative
    "classify a ticket (3K in, 200 out)":        dict(fresh=3_000, out=200),
    "extract from a 60K contract (2K out)":      dict(fresh=60_000, out=2_000),
    "parse a 150K filing (3K out)":              dict(fresh=150_000, out=3_000),
    "parse a 250K filing (3K out)":              dict(fresh=250_000, out=3_000),
    "sub-agent turn, 80K cached + 5K new":       dict(read=80_000, write=5_000, out=1_000),
}


def report():
    names = list(MODELS)
    print(f"{'per request':<40}" + "".join(f"{n:>12}" for n in names))
    for label, kw in SHAPES.items():
        costs = [request_cost(n, **kw) for n in names]
        print(f"{label:<40}" + "".join(f"  ${c:>9.5f}" for c in costs))
    print(f"\n{'40-turn agent session':<40}" + "".join(f"{n:>12}" for n in names))
    for label, kw in (("no compaction", {}), ("compact at 95K", {"compact_at": 95_000})):
        print(f"{label:<40}" + "".join(f"  ${session_cost(n, **kw):>9.4f}" for n in names))
    print("\nper million sessions, no compaction: " +
          "  ".join(f"{n} ${session_cost(n) * 1e6:,.0f}" for n in names))


if __name__ == "__main__":
    report()

With the defaults it prints:

$ python cliffcheck.py
per request                               Muse Ember   Haiku 5.5  GPT-6 Luna
classify a ticket (3K in, 200 out)        $  0.00040  $  0.00040  $  0.00040
extract from a 60K contract (2K out)      $  0.00700  $  0.00700  $  0.00700
parse a 150K filing (3K out)              $  0.01650  $  0.08250  $  0.01650
parse a 250K filing (3K out)              $  0.07950  $  0.13250  $  0.02650
sub-agent turn, 80K cached + 5K new       $  0.00132  $  0.00193  $  0.00193

40-turn agent session                     Muse Ember   Haiku 5.5  GPT-6 Luna
no compaction                             $   0.0704  $   0.3378  $   0.0917
compact at 95K                            $   0.0591  $   0.0804  $   0.0804

per million sessions, no compaction: Muse Ember $70,360  Haiku 5.5 $337,825  GPT-6 Luna $91,725

What it leaves out, on purpose:

• Tokenizers. The three count the same text differently. Haiku 5.5 uses the newer Anthropic tokenizer, which DataCamp measured at about 30% more tokens than Haiku 4.5 on the same text. Count a sample of your prompts with each vendor's token-counting endpoint before you trust a cross-vendor comparison.
• Output length. Effort settings and model verbosity change out per request, and on this tier output is 5x the input price. Ember's lower cost per task on Artificial Analysis is mostly that.
• Failures. A cheap request that fails and escalates costs the cheap call plus the expensive one. We priced that in the retry tax.
• How cached tokens count toward the line. None of the three vendors spells it out clearly. We count them. Check your first invoice.

Testing Ember on your traffic.

1. Pull a week of cheap-tier requests and bucket them by task type and by prompt length: under 100K, 100K to 200K, 200K to 272K, and over.
2. Run cliffcheck.py on each bucket's p50 and p95. If almost everything is under 100K and uncached, the price case for switching is zero. Decide on quality.
3. Shadow Ember on 5% of traffic in the buckets where it's cheaper or its benchmarks are stronger. Compare pass rate, output tokens per request and p95 latency against what you run now. Our model qualification protocol for Muse Spark applies to Ember unchanged.
4. Keep sessions on one model. Moving a live session from Haiku to Ember throws away its prompt cache, and at $0.004 per million that's cheap to read but not free to rebuild. Route per task or per session, as in the switch penalty.
5. Watch the line, not the sticker. Alert when a session approaches the cheapest model's line, and compact or move it before it crosses.

Where Nadir fits.

Three models at one price is the case where a single default is most clearly wrong. The cheapest of the three depends on the prompt's length, whether it's cached, and what kind of task it is, and all three change per request.

Send model="auto" and Nadir's trained classifier reads each prompt and picks a model from the ones you've configured, against the quality floor you set on the API key. Each response's metadata reports which model served it and what it cost, so the table above becomes a column in your own logs instead of an estimate.

If you'd rather keep calling providers directly, POST /v1/bucket returns simple, medium or complex with a probability for each, and your own code picks Ember, Haiku 5.5 or Luna for the simple bucket by length and task type.

Observe mode serves exactly the model you asked for and records what Nadir would have picked. A week of it gives you the request shapes cliffcheck.py needs, without changing a single response.

On the hosted gateway with your own provider keys, the provider bills you directly and Nadir charges a flat $0.002 per request, with the first 50 requests a month free. At $0.10 per million tokens that fee matters on tiny calls, so run the numbers on your traffic first. Savings depend on your workload, and nothing in this post forecasts yours.

Start with a free key or estimate your savings from your current model spend.

Conclusion.

Muse Ember makes three small agent models at $0.10 and $0.50. Under 100K tokens and uncached, they cost the same and you should choose on quality. Above that, the long-context line decides: Haiku 5.5 bills 5x past 100K, Ember 3x past 200K, Luna about 2x past 272K. In cache-heavy agent loops, Ember's $0.004 cache read makes it the cheapest of the three until its own line. And on Meta's own table it wins automation, ties terminal work and loses code generation. The sticker is a tie. The bill is a routing decision.

Sources: [Meta, Muse Ember](https://research.meta.ai/blog/muse-ember), November 9, 2026: pricing, long-context rates, context and output limits, availability, benchmark table, Artificial Analysis cost-per-task chart and partner comments. [Anthropic, Claude Haiku 5.5](https://www.anthropic.com/claude-haiku-5-5), October 7, 2026, and our [Haiku 5.5 pricing post](/blog/claude-haiku-5-5-pricing-100k-cliff-tokenizer-effort): rates, cache prices and the 100K line. [OpenAI, GPT-6 Luna](https://developers.openai.com/docs/models/gpt-6-luna) and [LLM Gateway](https://llmgateway.io/models/gpt-6-luna), retrieved November 11, 2026: rates and the 272K long-context pricing; the long-context cached rate is from third-party listings. [Compare AI, AI API pricing November 2026](https://compareai.today/blog/ai-api-pricing-november-2026): launch dates. Request shapes, the session model, compaction settings and the Ember cache-write rate are our illustrative assumptions.