Anthropic shipped Claude Haiku 5.5 on October 7 at $0.10 per million input tokens and $0.50 per million output, for prompts up to 100K tokens. GPT-6 Luna has listed at exactly $0.10 and $0.50 since September 22, and the cache prices match too: $0.01 to read, $0.125 to write. Nine days after Sonnet 5.5 matched GPT-6 Sol at $2 and $10, the cheap tier did the same thing.
Matching prices make the choice harder, not easier, because the cheap tier is where the volume lives: triage, summaries, test scaffolding, the jobs we already argued belong on a cheap Runtime. Pick between the two by gut feel and both end up on the board anyway, one in Claude Code and one in Codex. Then nobody can say which Agent is on what, which run finished, or which one wrote the triage summary that misrouted a bug last Tuesday.
TL;DR
Claude Haiku 5.5 and GPT-6 Luna cost the same only below 100K prompt tokens. Above that, Haiku 5.5 moves to $0.50/$2.50, while Luna stays at list until 272K and then rises to $0.20/$0.75, so long agent sessions are where the bills split. Anthropic’s launch table, the only vendor table with both models, has Haiku 5.5 scoring higher on every shared row. Its cost charts have Luna cheaper per attempt at every effort level on knowledge work and at every level but medium on computer use, where the two cost the same and Haiku 5.5 scores about 16 points higher. It is one vendor’s table, with no independent Haiku 5.5 result yet. Route by prompt size and by what you measure on your own Tasks; keeping both Runtimes is a defensible answer.
The price is identical until the prompt gets long
The headline match holds for one band of prompt sizes. Both vendors reprice long prompts, at different points and by different amounts:
| Input tokens in the request | Haiku 5.5, per 1M in / out | GPT-6 Luna, per 1M in / out |
|---|---|---|
| Up to 100K | $0.10 / $0.50 | $0.10 / $0.50 |
| 100K to 272K | $0.50 / $2.50 | $0.10 / $0.50 |
| Over 272K | $0.50 / $2.50 | $0.20 / $0.75 |
Anthropic’s pricing docs put it plainly: a prompt over 100,000 tokens pays higher prices. OpenAI’s Luna model page prices prompts over 272K input tokens at 2x input and cache rates and 1.5x output, for the full request. Batch processing halves both.
This matters more for agents than for chat, because an agent session re-sends its context every turn. Anthropic says 90% of requests to Haiku 4.5 fell under 100K, but a long coding session is not a typical request. Claude Code auto-compacts native 1M-context models, Haiku 5.5 included, at about 967K tokens by default. A long Claude Code run on Haiku 5.5 can therefore spend most of its turns above 100K, at five times the headline rate. Codex on Luna has another 172K tokens of room before its surcharge, and a smaller surcharge when it arrives.
Token counts do not compare cleanly across vendors either. Anthropic says the same text produces about 30% more tokens on Haiku 5.5 than on Haiku 4.5. One Hacker News commenter estimated that 100K modern Claude tokens are roughly 60K to 65K modern GPT tokens. That is a guess, not a measurement, but it points the same way: the same repository fills Haiku 5.5’s cheap band sooner.
What Anthropic’s table lets you compare
The Haiku 5.5 launch post has six rows with a Luna number. Haiku 5.5 figures are at max effort:
| Row | Haiku 5.5 | GPT-6 Luna | Where the Luna number comes from |
|---|---|---|---|
| GDPval-AA v2.1 (knowledge work) | 1620 | 1437 | Published figure cited by Anthropic |
| AA-Briefcase v1.1 | 1578 | 1336 | Published figure cited by Anthropic |
| OSWorld 2.1, offline subset | 72.4% | 48.9% | Run by Anthropic through OpenAI’s API, 82 tasks |
| Terminal-Bench 4.0 | 39.2% | 16.4% | Public leaderboard, Codex CLI at max effort |
| FrontierCode 1.1 (Main) | 46.4% | 42.4% | Published figure cited by Anthropic |
| Chartography, no tools | 46.4% | 29.1% | As reported by Surge AI |
Haiku 5.5 leads every row. Two caveats keep that from being a verdict. It is Anthropic’s table, and the launch page charts score against cost per attempt, which tells a different story than the scores alone:
| Effort | OSWorld: Haiku 5.5 | OSWorld: Luna | GDPval-AA: Haiku 5.5 | GDPval-AA: Luna |
|---|---|---|---|---|
| low | 42.0%, $0.07 | 19.2%, $0.04 | 1125, $0.012 | 1036, $0.004 |
| medium | 53.3%, $0.13 | 37.5%, $0.13 | 1277, $0.030 | 1262, $0.020 |
| high | 61.3%, $0.18 | 42.3%, $0.14 | 1420, $0.089 | 1344, $0.030 |
| xhigh | 67.6%, $0.28 | 44.8%, $0.17 | 1513, $0.267 | 1364, $0.050 |
| max | 72.4%, $0.61 | 48.9%, $0.21 | 1620, $0.866 | 1437, $0.090 |
On GDPval-AA, Luna is cheaper per task at every effort level. On OSWorld it is cheaper at every level except medium, where the two cost about 13 cents an attempt. On computer use the gap in score is wide enough not to matter: Haiku 5.5 at medium beats Luna at max for less money. On knowledge work it nearly closes. Haiku 5.5 at high and Luna at max both cost about nine cents a task and land 17 Elo points apart, and Haiku 5.5’s max costs nearly ten times Luna’s.
Two more limits. OSWorld’s headline is partial credit; Anthropic’s system card puts Haiku 5.5’s strict pass rate at 37.1%, and publishes no strict figure for Luna. What that does to the review queue is the subject of our browser-agents post. And neither model is a coding lead: Anthropic itself says Sonnet 5.5 and Opus 5.5 remain better choices for complex agentic coding.
The Runtime around each model
The model is half the decision. Each one usually arrives inside a different Runtime, and the Runtimes behave differently on a board.
Claude Code on claude-haiku-5-5. It needs Claude Code v2.1.293 or later; start it with claude --model claude-haiku-5-5 or switch with /model. The haiku alias means Haiku 5.5 only on the Anthropic API and still resolves to Haiku 4.5 on Bedrock, Google Cloud, Microsoft Foundry and Claude Platform on AWS, so pin the full id. Default effort is medium, and Claude Code cannot turn thinking off on Haiku 5.5. The new monthly API credits for Max and Team plans do not cover Claude Code, so they do not pay for this Runtime.
Codex on gpt-6-luna. Luna runs in Codex on Plus, Pro, Business, Enterprise and Edu plans. Its API reasoning effort ranges from none to max, with medium as the default, so both models start at medium unless someone changes it.
One behavior difference belongs on the board rather than in a footnote. Haiku 5.5 runs safety classifiers that can decline a request, with no server-side fallback, and Anthropic’s system card says it over-refused more than any other model in its automated behavioral audit. A refusal is a run that ends without a result. It should come back to the Task as a visible failure, not vanish into a terminal nobody is watching.
How to compare them on your own Tasks
Sharkly does not pick models. The Agents documentation says: “The Agent follows the Runtime’s default model. It does not promise or display a specific model name. To change models, specify one in Custom arguments on the Agent or Runtime, for example specify model: model-name.” There is no model dropdown on the Agent. So the setup is two Agents, one per Runtime, each named for its lane:
Agent A: Claude Code Runtime, Custom arguments model: claude-haiku-5-5
Agent B: Codex Runtime, Custom arguments model: gpt-6-luna
Tasks: the same description and starting commit, one Task per Agent,
drawn from jobs you actually hand the cheap tier
Accept: one acceptance check, written before either run starts
Record: accepted y/n, review minutes, reruns, refusals,
whether the run crossed 100K (Haiku) or 272K (Luna) input tokens,
provider cost from your own Anthropic and OpenAI bills
Model usage runs through the subscriptions or API keys configured in those tools, so both bills stay with the providers. The method in full, with the review-minutes argument, is in our Sonnet 5.5 vs GPT-6 Sol comparison and how to compare coding agents on your own codebase. The Haiku-specific setup is in running Claude Haiku 5.5 agents in Sharkly.
The extra column this pair needs is the prompt-size one. A cheap run that crossed 100K on Haiku 5.5 was not a ten-cent run, and a cheap run that needed two reruns was not cheap at all, as when cheap models cost more argues.
Why “both” is a legitimate answer
The published evidence does not produce one winner, and the price table almost guarantees a split.
Use Haiku 5.5 when prompts stay under 100K, when the job is browser or desktop work where its OSWorld margin is widest, or when the cheap work runs as a subagent under a Claude lead (the subagent or its own Agent post covers where that work should live). Use Luna when jobs routinely carry 100K to 272K tokens of context, such as long log digests or large diffs, or when the lowest price per attempt decides it. If you only run Claude Code and your cheap jobs are short, you may not need a second cheap Runtime at all.
Keeping both works only if the Task, not the Runtime, is the record. Agents research, execute, test, and report. People set direction, grant authority, and accept the result. Two labs priced the cheap tier identically within three weeks, and either can move next; context, progress, blockers, results and human review should stay visible from request to release whichever Runtime wins the next round. If you want to keep using multiple coding agents rather than committing to one ecosystem, that’s the problem Sharkly is designed around.
