I used to pick coding models the same way people pick sports cars: choose the most powerful one and pretend the fuel bill is somebody else's problem.
That worked when I was asking one question at a time. Then I started using agents for real engineering work.
An engineering agent does not answer once and disappear. It reads the repository, searches for related code, opens the wrong file, finds the right file, proposes a change, runs a test, breaks something, reads the error, fixes the change, and runs the test again. Sometimes it also writes a surprisingly thoughtful essay about the three lines it just modified.
By the time one task is finished, the model may have been called a dozen times. Suddenly, model pricing is not a footnote. It is part of the architecture.
That is how GPT-5.6 Luna with high reasoning effort became my default.
The cheap model that gets the job done
OpenAI positions Luna for cost-sensitive, high-volume work, and the pricing makes that very clear. As of August 2026, GPT-5.6 Luna costs $0.20 per million input tokens and $1.20 per million output tokens. Claude Sonnet 5 costs $2 for input and $10 for output.
So Luna's input is ten times cheaper, and its output is about 8.3 times cheaper.
Take an agent run that consumes 100,000 input tokens and produces 20,000 output tokens. Luna costs about $0.044. Sonnet costs about $0.40. Neither amount is terrifying on its own, but agents are enthusiastic employees. Give them access to a repository and they will inspect everything, call every tool, and occasionally create a strategic roadmap for changing a variable name.
Repeat that across pull requests, bug fixes, failed CI jobs, and background tasks, and the difference stops being theoretical.
Using Luna means I can let the agent iterate without feeling that every failed test needs approval from Finance.
Why I use high reasoning effort
Cheap is useful only if the model can finish the work. I do not run Luna with minimal reasoning and hope for a miracle. I use high reasoning effort.
That setting gives it enough room to trace behavior across files, understand unfamiliar abstractions, choose tools, react to command failures, and verify the result before declaring victory. In my experience, that is enough for a large part of normal engineering work.
It is not the smartest model available, and I do not need it to be. My default model does not have to solve every impossible architecture problem. It has to handle routine features, localized bugs, tests, refactoring, and repository exploration without turning each task into an expensive research project.
There is a temptation to treat "accurate enough" as an insult. I see it differently. Most engineering tasks do not need a model to contemplate the nature of software. They need it to follow the repository instructions, make a focused change, preserve unrelated code, understand the compiler output, and actually run the tests.
Luna does that well enough for me, especially when the agent harness is doing its job. Good context, sensible permissions, small changes, and real test feedback matter just as much as the model. A cheaper model inside a disciplined workflow can be more useful than an expensive model confidently wandering through the codebase.
Speed matters too. A small delay is easy to ignore in one response. Across fifteen sequential agent turns, it becomes enough time to question your career choices. Luna keeps the loop moving. It can inspect, attempt, fail, correct, and verify without making every step feel like a separate meeting.
And what about Claude Sonnet?
Claude Sonnet is a capable model. There are difficult tasks where I am happy to use it. It is simply not my default.
The obvious reason is price. The less obvious reason is output efficiency. In my experience, Sonnet often gives me more explanation than the engineering loop needs. I ask for a patch and sometimes receive the patch, a retrospective, and the opening chapter of a management book.
That can be useful when I am exploring a decision. It is less useful when the agent is supposed to edit a file and run the tests. Verbose output is not only more to read; output tokens are also the expensive tokens.
Anthropic's documentation says Claude 4.7 and later can produce roughly 30% more tokens for the same text than models using its previous tokenizer, although the exact difference depends on the workload. That is not the same as saying the model is always verbose, but it is another reminder that token behavior belongs in the engineering decision.
For autonomous execution, I care more about correct edits and passing tests than an eloquent account of the model's emotional journey.
My approach is simple: start with Luna High and escalate when the task earns it. If the architecture is genuinely ambiguous, failures remain unexplained, or the work involves subtle security or concurrency behavior, I will reach for a stronger model. That is not model loyalty. It is routing.
The best model is not always the one that wins the benchmark. For agentic engineering, I care about the cost of the completed task, how long it took, how many retries it needed, whether the tests passed, and how much cleanup I had to do afterward.
For my workload, GPT-5.6 Luna with high reasoning effort currently hits the useful middle: very cheap, very fast, and accurate enough to handle the common path.
It is not the model I want solving every problem. It is the model I want holding the wrench most of the time.
Pricing sources: OpenAI model documentation and Anthropic pricing documentation, checked August 14, 2026.
Top comments (0)