# GPT-5.6 Luna Reviews Cost Half a Cent. Security Breaks the Bargain. **Summary:** In a 50-PR benchmark, GPT-5.6 Luna cost $0.0041 per review but found only 9 of 24 security bugs, and 24 of its findings failed verification. I would use it as a scout, then escalate by code risk. - Canonical: https://markhuang.ai/news/gpt-5-6-luna-review-attention-tax - Language: en - Author: [Mark Huang](https://markhuang.ai/about) - Published: 2026-09-14 - Section: News - Tags: GPT-5.6 Luna, GPT-6 Astra, AI Code Review, Model Routing, Software Security - Source: [Entelligence](https://entelligence.ai/blogs/gpt-5.6-luna-vs-gpt-6-astra-is-a-1.20-model-good-enough-for-code-review) - License: https://creativecommons.org/licenses/by-nc/4.0/ --- ![Two code inspection machines sort metal code tiles and cracked security locks, with the cheaper scanner producing many amber warnings and the precision scanner using a focused blue beam](https://cdn.markhuang.ai/news/gpt-5-6-luna-review-attention-tax/hero.webp) *A cheap review stops being cheap when its noise and misses consume the engineering time it was supposed to save.* [Entelligence ran GPT-5.6 Luna and GPT-6 Astra across the same 50 public pull requests](https://entelligence.ai/blogs/gpt-5.6-luna-vs-gpt-6-astra-is-a-1.20-model-good-enough-for-code-review). Luna cost $0.20 for the full run, or $0.0041 per review, and found 69 verified bugs. Astra cost $5.66 and found 92. At first glance, Luna looks like the obvious default. Then the review work comes back into view. Twenty-four of Luna's 93 findings failed verification, compared with 4 of Astra's 96. Luna also found 9 of 24 security bugs, while Astra found 19. I would use Luna as a first pass, but I would not let the token price decide which reviewer gets the last word. ## Twenty cents bought coverage, not confidence The test used ten pull requests each from Cal.com, Sentry, Discourse, Keycloak, and Grafana. Both models received the same diffs and a bug-only prompt covering correctness, security, concurrency, resource use, and error handling. The underlying repositories are public in the [AI Code Review Evals organization](https://github.com/AI-Code-Review-Evals). Entelligence pooled findings from Luna, Astra, GPT-5.6 Sol, and its own reviewer. Astra and Sol judged each anonymized issue against the diff, and an issue counted only when both called it real. They agreed on 91% of findings and accepted 143 distinct bugs. The benchmark has no complete list of every bug in each pull request, so 143 is a floor rather than a recall measurement. Astra was one of the judges too. Requiring Sol to agree reduces that advantage without removing it. ## False positives spend somebody's time Luna's token bill was tiny. Its attention bill was not. A developer would have had to reject roughly one in four of its findings in this run. If those comments appear on every pull request, people may learn to skim the bot. That is when a correct warning becomes easiest to miss. This is not unique to Luna. A 2026 [study of 31,073 agentic code-review comments and developer responses](https://arxiv.org/abs/2607.03316) found that 56.3% were rejected. The study examined CodeRabbit, so that rate cannot be compared directly with this benchmark. It does show why accepted findings and reviewer behavior belong next to precision on the scorecard. GitHub's [responsible-use guidance for AI security and quality features](https://docs.github.com/en/code-security/responsible-use/security-and-quality-ai-features) warns about incomplete detection, false positives, limited context, and nondeterminism. A comment that costs a fraction of a cent to generate can still take minutes to investigate. ## Security breaks the bargain The category split matters more to me than the overall 69-to-92 score. Luna found 39 data and logic bugs versus Astra's 47, and 10 concurrency bugs versus 13. The security gap was much wider: 9 for Luna and 19 for Astra. Keycloak showed the same weakness at repository level. Luna found 6 verified bugs there, Astra found 14, and only 50% of Luna's Keycloak findings held up. Entelligence says most of those benchmark pull requests changed authentication or permission logic. Two misses involved reusable recovery codes and a global permission overriding denials on individual clients. "Good enough on average" is a poor rule for code with that kind of reach. OpenAI describes [GPT-5.6 Luna](https://developers.openai.com/api/docs/models/gpt-5.6-luna) as a model for cost-sensitive, high-volume work and prices it at $0.20 per million input tokens and $1.20 per million output tokens. [GPT-6 Astra](https://developers.openai.com/api/docs/models/gpt-6-astra) costs $10 and $50 at the same units. Luna delivers a lot of coverage for its price. I would not ask every class of code to accept the same coverage. > **Info:** > > I would classify risk before the model reviews anything. Authentication, authorization, payments, secrets, data deletion, and boundary checks should enter the stronger lane because of what the code can affect, not because a cheap reviewer happened to sound uncertain. ## A diff cannot tell me what it might break Both models saw the diff and nothing else. They had no repository history, call graph, or production data. That keeps the comparison controlled, but removes the context needed to recognize that a modest-looking change sits inside a login flow or behind a financial action. I would not ask Luna to route itself. The surrounding system should know which paths have security owners and which services handle money or identity. It can send those changes to Astra, a security tool, or a human specialist before any model writes a comment. Luna still earned a place in the workflow. It found 25 verified bugs that Astra missed. Running both models found 117 of the 143 accepted bugs for $5.86, compared with Astra's 92 for $5.66. I would reserve that two-model pass for selected changes and for audits of the cheap lane. ## One run is a shaky promise Entelligence reran ten pull requests twice with identical settings. Each model had 15 verified bugs in its first run on that subset. Astra reproduced 10 in both repeats; Luna reproduced 7. The sample is small, but the movement is enough to make single-pass claims uncomfortable. The source also checked whether public code might have leaked answers into training. The pull requests dated from 2013 through July 25, 2025, so none came after either model's stated cutoff. The benchmark defects were inserted deliberately, which means the exact faulty diffs were not old fixes the models could recall. The surrounding code was public, though, and familiarity with its correct form could still help. This test cannot settle that concern. I treat the result as a candidate evaluation, much like the build comparisons in [my argument for model failure rates](https://markhuang.ai/news/model-build-offs-need-failure-rates). It tells me which model deserves a trial on my repositories. It does not remove that trial. ## How I would spend the savings I would start Luna on routine pull requests with a narrow prompt and require each finding to describe a concrete failure path. I would track accepted comments and check whether sampled clean reviews contain bugs found later by a stronger reviewer. High-risk paths would skip that default. They would get stronger model review, deterministic security checks where available, and a responsible human. I would sample the supposedly safe lane too, because the router can be wrong before either reviewer begins. The saved token budget should pay for verification instead of a larger pile of comments. ## A half-cent review still needs an owner I would use Luna as a scout. It is cheap enough to cover routine changes, and it found real bugs that Astra missed. I would not let it clear authentication or permission code, and I would not measure success by comments generated. The metric I want is cost per accepted finding, followed by the harder check: what escaped? Entelligence's result makes Luna worth testing. Its security gap makes routing and audits part of the deployment cost.