GPT-5.6 Luna costs $0.20 per million input tokens and $1.20 per million output tokens on OpenRouter. With prompt caching, that drops to $0.02 per million cached input tokens. At that price, a complex multi-step agent workflow that used to cost $1 is now $0.10.
This is not a marginal improvement. It's a phase transition in what you can build.
The HN thread on Calvin French-Owen's "Small Models Have Arrived" (469 points, 39 comments) captured the sentiment concisely: "Those of us without fable-sized expense accounts noticed this quite a while back." But the data bears out that the inflection point is here, across every major model provider.
Let me show you the numbers, the architecture changes that enabled them, and what they mean for production engineering. OpenAI cut GPT-5.6 Luna prices by 80% from GPT-5.5 (announced via Sam Altman on X). That's not a regular price drop. It's a structural break driven by inference optimization and model architecture improvements.
Here's the current landscape for small/cheap frontier models:
| Model | Input (per 1M tokens) | Output (per 1M tokens) | Active Parameters |
|---|---|---|---|
| GPT-5.6 Luna | $0.20 | $1.20 | Unknown (proprietary) |
| GLM-5.3-Flash | $0.15 | $0.50 | 18B of 320B (MoE) |
| Qwen3.8-Flash | $0.16 | $0.47 | 6B of 125B (MoE) |
| DeepSeek V4 Flash | ~$0.20 | ~$0.80 | 13B of 284B (MoE) |
Every one of these models ships at or below $1.20 per million output tokens. For comparison, GPT-5.6 Sol runs ~$10/M output, and Claude Opus 4.8 runs even more. The gap between "fast and cheap" and "frontier" is now a factor of 10–20× on cost, while the capability gap has shrunk.
One HN commenter running GPT-5.6 Luna in production reported: "Luna showed a better ROI on cybersecurity benchmark — 6× less expensive while only sacrificing marginal F1 score." (Semgrep benchmark, confirmed.)
Every major release in 2026 uses MoE. GLM-5.3-Flash activates only 18B of 320B total. Qwen3.8-Flash-Next activates 6B of 125B. DeepSeek V4 Flash activates 13B of 284B.
The implication is straightforward: you get the representational capacity of a 300B-parameter model while paying the inference cost of a 6B–18B model. The router network learns which experts to activate per token, and the sparsity ratios are aggressive — Qwen's 125B total / 6B active is a 95% sparsity rate.
Luna's pricing structure tells you exactly where the margins live:
The batch API is effectively half price. If you can batch your inference workloads, you're running at $0.10/M input — practically free for most applications.
Artificial Analysis's intelligence comparison chart makes this visible. GLM-5.3-Flash sits on the Pareto frontier for open-source models — meaning there is no open-weight model that beats it on both quality and cost. GPT-5.6 Luna occupies a similar position for proprietary models.
The old assumption was "small models are worse, use the big one." The new reality is: pick the smallest model that passes your eval, because the cost difference between tier N and tier N+1 is often an order of magnitude.
Calvin's example in the original post is illustrative: a daily personalized news site. With pre-Luna generation models (Sonnet class), each run cost ~$1. With Luna, ~$0.10. At $30/month subscription, that's the difference between losing money on every user and having healthy margins.
The old playbook for consumer apps (free tier → ads → scale) doesn't work when every request costs real money. Luna-level pricing changes that equation. You can now deliver AI features in consumer products without the inference cost eating your entire budget.
Peter Rein's framing (from the article) splits work into two categories:
Most business operations fall into bucket 2. Sales follow-ups, customer support triage, code review triage, spec drafting, status updates. These are tasks where "good enough and immediately responsive" beats "perfect but slow."
GPT-5.6 Luna doing 100 tokens per second makes it viable for real-time agent loops that used to be too slow or too expensive. One HN commenter described building a "family assistant" for $5 in API costs and running it day-to-day for cents.
The real unlocked capability is multi-step agent workflows. When each LLM call costs $0.01–$0.05, you can afford 10-step reasoning chains, verification loops, and retry logic. When each call costs $0.50–$1.00 (Sonnet/Terra class), you optimize aggressively and cut corners.
Luna pricing makes the naive implementation (call the model, check the result, call again if wrong) economically viable. That changes how you design agent systems — you optimize for correctness first, cost second.
Small models are not frontier models. GPT-5.6 Sol still outperforms Luna on complex reasoning, novel problem-solving, and tasks requiring deep domain knowledge. The Semgrep benchmark confirms this — Sol catches vulnerabilities Luna misses, and at higher precision.
MoE has a cold-start problem. Router networks need to learn which experts to activate. For novel tasks the model hasn't been fine-tuned on, the routing can be suboptimal, and you pay the "total parameter" memory cost even though you're only using the "active parameter" compute.
Caching is not free infrastructure. The prompt caching pricing tiers at OpenAI (272K+ tokens) are generous, but building a system that reliably hits cache requires engineering attention. You don't get the $0.02/M rate without designing for it.
Not all small models are created equal. The table above shows prices varying by 2.5× on output. The quality variance is larger. Run your own evals. Qwen3.8-Flash may be right for your coding pipeline; GLM-5.3-Flash may be better for agentic tasks; Luna may be better for general reasoning. The only way to know is to measure.
The small model trend has three trajectories worth tracking:
Distillation from frontier models. OpenAI, Google, and Anthropic all distill their best models into smaller, cheaper variants. As the frontier advances, the distilled versions get better without getting more expensive.
On-device inference. GLM-5.3-Flash's inference stack runs on domestic Chinese chips. Qwen runs on consumer hardware. The next logical step is models good enough to run locally, eliminating API costs entirely for sensitive workloads.
Agent-native small models. The current generation of small models was designed for chat and text generation. The next generation will be designed for tool use, long-horizon planning, and multi-turn agent loops — tasks where speed and cost compound.
For April 2025 you needed a $10-per-million-parameter budget to run useful inference. For August 2026, you can run production-quality agent loops for **$0.02 per million tokens** with caching, or **$0.50 per million output** on a flash-tier model. The economic barrier to building AI-native products has dropped by roughly two orders of magnitude in 18 months.
If you're evaluating models for a new product today: run your evals on the small models first. You might find they're good enough. And "good enough" at 10–20× lower cost is the kind of unit economics that funds the next round.
Sources: Calvin French-Owen — Small Models Have Arrived (HN 469 pts, 39 comments), OpenRouter pricing for GPT-5.6 Luna, Semgrep GPT-5.6 Benchmark, OpenAI GPT-5.6 announcement (315 pts), Artificial Analysis model intelligence comparison. Pricing data from OpenRouter API as of Aug 2026.