AI Tools

GPT-5.6 Luna vs GPT-6 Astra: which model should review your pull requests?

Published 2026-09-15 · Researched and price-checked on official sources

GPT-5.6 Luna vs GPT-6 Astra comes down to one measured number: reviewing 50 public pull requests cost $0.20 with Luna and $5.66 with Astra, per Entelligence AI's September 14, 2026 benchmark. Astra verified 92 bugs to Luna's 69 at 96% precision against 74%, and Luna missed 15 of the 24 security bugs.

Key facts

What matters

OpenAI's list rates, verified September 15, 2026: GPT-5.6 Luna is $0.20 per million input tokens and $1.20 output, GPT-6 Astra is $10.00 and $50.00.
On Entelligence AI's 50-pull-request benchmark, Luna found 69 verified bugs against Astra's 92, at $0.0030 versus $0.061 per verified bug.
The gap is shaped by code type: on Keycloak's authentication and permission pull requests Luna found 6 verified bugs to Astra's 14, with half its findings failing verification.
Batch and Flex tiers halve both models and cached input costs a tenth of input, so a queued review pipeline pays well under standard rates.
Running both models found 117 of 143 verified bugs for $5.86, about 3.5% more spend than Astra alone for 27% more verified bugs.

What GPT-5.6 Luna and GPT-6 Astra are

GPT-5.6 Luna is OpenAI's cost-optimized tier. Its model page describes it as built for cost-sensitive, high-volume workloads and places it roughly where the nano models sat in earlier GPT-5 families. GPT-6 Astra is the opposite end of the same catalog, sold for the hardest end-to-end work in coding, computer use and research.

The shared specs matter more than the positioning. Both carry a 1,050,000 token context window, accept up to 922,000 input tokens and return up to 128,000 output tokens. The knowledge cutoffs sit ten weeks apart: February 16, 2026 for Luna and April 30, 2026 for Astra. The reasoning controls differ too. Luna's reasoning.effort accepts none, low, medium (the default), high, xhigh and max, while Astra's lowest setting is low. Only the cheap model can be told to skip reasoning entirely, which is the setting you want for a mechanical pass over a diff.

GPT-5.6 Luna vs GPT-6 Astra pricing, verified

Per OpenAI's pricing page on September 15, 2026, Luna costs $0.20 per million input tokens against Astra's $10.00, and $1.20 per million output tokens against $50.00. That is 50x on input and about 42x on output. Cached input bills at a tenth of the input rate on both models ($0.02 and $1.00), and cache writes at 1.25x input ($0.25 and $12.50).

Three official service tiers bend those numbers, and they are the ones an automated review pipeline should care about:

Batch and Flex bill at 50% of standard, so Astra drops to $5.00 input and $25.00 output, and Luna to $0.10 and $0.60.
Fast mode doubles the rate: Astra $20.00 in and $100.00 out, Luna $0.40 and $2.40. Fast mode is unavailable for GPT-6 Astra on EU data residency.
Long context is the trap. Once input passes 272,000 tokens the whole request is repriced at 2x input and 1.5x output, which turns Astra into $20.00 and $75.00 and Luna into $0.40 and $1.80. No part of that request stays at the short-context rate.

OpenAI also charges a 10% uplift on regional processing (data residency) endpoints for models released on or after March 5, 2026. OpenRouter listed the same headline rates, with the batch variants at half, on September 15, 2026, so there is no cheaper resale channel to route around list pricing.

What one code review actually costs

The benchmark compares the two models on 50 public pull requests, ten each from Cal.com, Sentry, Discourse, Keycloak and Grafana, with the same prompt on the same diffs. Prompts, raw model outputs, judge verdicts and scoring scripts ship with the benchmark post, so the per-review averages can be rebuilt from OpenAI's rates: a Luna review averaged $0.0041, an Astra review $0.113.

Run that arithmetic yourself and you get a budgeting tool. Astra's reported average of 688 output tokens per review bills at $0.034, and adding roughly 7,900 input tokens at $10 per million brings the total to $0.113. Luna's 2,104 output tokens bill at $0.0025, and the same 7,900 input tokens at $0.20 per million add $0.0016, for $0.0041. Both match the published averages within about 1%. Substitute your own diff size and expected number of findings and you have a per-review estimate for your repository.

Cached input is where a review bot beats both figures. Sending the same repository context with every pull request is exactly the pattern prompt caching is priced for: $1.00 per million on Astra instead of $10.00, and $0.02 instead of $0.20 on Luna. If the pipeline runs on a queue rather than inside a blocking pre-merge check, Batch pricing halves the standard rate again, which would put that 50-pull-request run near $2.83 instead of $5.66.

Where Luna is not good enough yet

The benchmark splits results by repository and by bug class, and that split is the useful part for a buyer. Luna came within two verified bugs of Astra on Sentry, Discourse and Grafana. Cal.com widened to 21 against 30. Keycloak was the outlier: 6 verified bugs against 14, with only 50% of Luna's Keycloak findings surviving verification against Astra's 93%.

Keycloak is an identity and access management server, and most of its benchmark pull requests change authentication and permission logic. The bug classes point the same way: 39 data and logic bugs against Astra's 47, 10 concurrency bugs against 13, and 9 of 24 security bugs against Astra's 19. Two of the misses were federated recovery codes that were never marked as used, letting one code be redeemed twice, and a global view permission that overrode denials set on individual clients. Neither is visible on a single line of a diff.

The noise costs money too. About one in four Luna comments did not hold up, against four of 96 for Astra. A review bot that posts false findings teaches developers to skim past the true ones, and that bill never appears on a token invoice.

How to route reviews without paying Astra for everything

On this evidence the cheap model should carry the routine volume and the expensive one should carry the code where a miss is expensive. Authentication, authorization, payment and permission paths are the categories that separated the two models most; ordinary data and logic fixes did not.

Default to Luna and escalate by path. Route files on login, permission or payment paths to Astra. The Keycloak split, 6 verified bugs against 14, is the clearest argument for that rule.
Run both models on the same diff if coverage beats cost. Their union found 117 of 143 verified bugs for $5.86 against 92 for Astra alone: 3.5% more spend for 27% more verified bugs, paid for in extra noise from Luna.
Push non-urgent reviews to Batch or Flex at half price. A nightly sweep of merged commits fits; a blocking pre-merge gate does not.
Measure on your own code before you budget. The published method is short: collect 30 to 50 merged pull requests that later needed a fix, run both models with an identical prompt, judge with a model that is not one of the two under test, and compare cost per verified bug by repository and bug class.

The benchmark leaves one gap worth flagging. GPT-5.6 Terra, OpenAI's middle tier at $2.00 per million input tokens and $12.00 output ($4.00 and $18.00 above 272K input), was not in the test, so whether a $2.00 model already clears the precision bar for your code is still unanswered.

What the benchmark does not prove

Four limits are worth reading before you commit budget. Each pull request was reviewed once, apart from ten that were repeated; there Astra reproduced 10 of its 15 findings on both reruns, and Luna 7 of 15, so single-run counts move. Astra is one of the two judges that verify findings, a bias the vendor states and only partly cancels by requiring GPT-5.6 Sol to agree. Every pull request predates both models' knowledge cutoffs, February 16 and April 30, 2026, so nobody has tested whether the ranking holds on code newer than the model. And both models saw only the diff, with no repository history or call graph.

There is a commercial interest to weigh as well: Entelligence AI sells a code review product and a model router, and a result in which a $1.20 model covers three quarters of a $10 model's bugs supports that business. The raw outputs are published, which is what makes the numbers usable, but read the 28x headline as a measurement on 50 diff-only pull requests rather than a rule for your codebase.

At a glance

Metric	GPT-5.6 Luna	GPT-6 Astra
Standard input / output	$0.20 / $1.20	$10.00 / $50.00
Cached input (10% of input)	$0.02	$1.00
Cache writes (1.25x input)	$0.25	$12.50
Batch or Flex input / output	$0.10 / $0.60	$5.00 / $25.00
Fast mode input / output	$0.40 / $2.40	$20.00 / $100.00
Over 272K input tokens	$0.40 / $1.80	$20.00 / $75.00
Context window	1,050,000 tokens	1,050,000 tokens
Max output tokens	128,000	128,000
Knowledge cutoff	February 16, 2026	April 30, 2026
reasoning.effort options	none through max	low through max

GPT-5.6 Luna and GPT-6 Astra rates per 1M tokens, OpenAI pricing page verified September 15, 2026

FAQ

Is GPT-5.6 Luna good enough for code review?

For ordinary correctness bugs, close: it found 69 of the 92 verified bugs Astra found across the 50 pull requests, including 39 of Astra's 47 data and logic bugs. For authentication and permission code it is not, finding 9 of the 24 security bugs against Astra's 19 and missing 8 of the 14 Keycloak bugs.

How much cheaper is GPT-5.6 Luna than GPT-6 Astra per review?

About 28x on the published benchmark: $0.0041 per review against $0.113, or $0.0030 per verified bug against $0.061. The list rates behind that gap are $0.20 and $1.20 per million tokens for Luna against $10.00 and $50.00 for Astra.

Should I run both models on every pull request?

If the team can absorb extra false comments, yes. Running both found 117 of 143 verified bugs for $5.86 across the 50 pull requests against 92 for Astra alone, so the second model bought 25 more verified bugs for roughly 3.5% more spend. The trade is Luna's 74% precision.