The most interesting model release is not always the one that tops the biggest intelligence benchmark. Sometimes it is the one that looks as if it might finally erase an old trade-off.
GPT-5.6 Luna looked like that model.
OpenAI introduced Luna as the fastest and most affordable member of the GPT-5.6 family. For BulletBench, that sounded almost purpose-built. We did not need another model that could find a brilliant move after twenty seconds. We needed one that could find a good move now.
Then we started the clock.
Luna's intelligence never got a chance
We tested GPT-5.6 Luna at low and medium reasoning, on both standard and priority service. Across those four configurations it played 96 games.
It lost 71 of them on time.
At Lightning, where each player gets ten seconds plus one second back per move, Luna flagged in 29 of 32 games. At Bullet, with 60 seconds for the whole game, it flagged in 28 of 32.
The standard medium-reasoning configuration lost all eight Lightning games on time and seven of eight Bullet games. Dropping Luna to low reasoning did not solve the problem. Neither did paying for the priority service lane. Luna's best Bullet configuration was low reasoning on priority service, and even there it lost six of eight games on the clock and managed a ladder rating of 358.
The individual configurations have only eight games per time control, so their rating intervals are wide. The latency pattern is not.
This was not a notation problem. Luna's illegal-move rate across Lightning and Bullet was zero. It understood the position, selected legal moves and sometimes built perfectly playable games. It just spent too long doing it.
And to be precise, the API did not "time out". BulletBench pauses the clock for provider infrastructure failures. Luna ran out of game time because real wall-clock response latency is deducted move by move. That is the same latency a router, voice agent or inline product feature experiences.
The tail was especially damaging. Standard Luna at medium reasoning had a median Lightning move time of 1.4 seconds, which sounds close to viable. Its p90 was 5.3 seconds. In a sequential workload, a few long pauses are enough to erase dozens of acceptable responses. Averages make good launch slides. Tail latency decides whether the system works.
Flash Lite is still sitting in the same chair
When BulletBench launched on 3 July, Gemini 3.1 Flash Lite was the dependable all-rounder. It was not the strongest model in every column. It was the model that stayed useful when the clock got hostile.
It still is.
On the standard service lane, Flash Lite currently posts:
- 876 ladder Elo at Lightning, with a median move time of 0.84 seconds and zero time losses in 32 games
- 863 at Bullet, with a median move time of 0.88 seconds and eight time losses in 32 games
- 827 at Blitz, again with zero time losses in 32 games
No other standard API lane stays above 800 across all three fast formats.
There is an important qualification. Gemini 3.5 Flash beats Flash Lite in individual columns, and priority configurations can top a particular time control. Flash Lite is not literally first everywhere. Its distinction is consistency: normal serving, sub-second median responses and useful chess at every fast clock.
That is also why its position can feel slightly unsatisfying. Flash Lite is not winning because BulletBench has discovered that it is the smartest model in the world. It is winning because it combines enough chess ability with the discipline to remain available when a decision is due.
The wider Spring Prompt benchmark suite makes the inversion even clearer. Across 22 task areas, Luna places in the top three nine times. Flash Lite does not place in the top three at all. By broad task performance, Luna is the more capable model. Under a hard clock, the ranking flips.
In other words, it often wins by still being there.
That sounds like victory by default. In production, default reliability is a capability. A routing decision that arrives after the user request has already been sent is not a better decision. A safety check that completes after the action is taken is not safer. An agent that chooses the perfect tool after the interaction has gone stale is not more intelligent in any useful sense.
Fast alone does not win either
If BulletBench only rewarded speed, the leaderboard would look very different.
Qwen 3.5 Flash answers in about 0.43 seconds per move, roughly twice as fast as Flash Lite, and did not lose a single one of its 108 games on time. Its Bullet rating is 589, almost 300 points behind Flash Lite, and roughly one in ten move attempts is illegal.
Several smaller models are faster still in practical terms, yet play barely above the random-move anchor. They can always answer before the deadline. The answer is simply not good enough.
That leaves the market split into three groups:
- models with real intelligence that cannot reliably fit inside a tight deadline
- models with excellent speed and too little judgement to trust with the decision
- Gemini 3.1 Flash Lite, sitting in the useful middle and waiting for a serious challenger
The empty space is not for another merely fast model. It is for a genuinely smart, lightning-fast one.
The model we are still waiting for
The missing model does not need the highest score on every long-horizon reasoning benchmark. It needs to maximise intelligence inside a hard time budget.
That means more than a good median. It means:
- sub-second p90 latency, not a sub-second average hiding five-second stalls
- explicit budget awareness, so the model can stop thinking before the answer becomes useless
- strong first-pass judgement on routing, classification and tool-selection tasks
- predictable serving under load
- economics that work at millions of calls, not just in a demo
Most model development still treats extra reasoning as an uncomplicated good. More test-time compute buys a better answer, so the dial keeps turning upwards. For coding agents and deep research, that can be exactly right. For the small decisions inside interactive systems, it misses the product requirement.
The model needs to treat time as part of the problem.
Luna's result is disappointing precisely because the intelligence appears to be there. In Spring Prompt's structured-output benchmark, Luna shows top-tier quality when the task lets it finish. OpenAI also positioned it as the fastest and most affordable member of the family. BulletBench exposed the gap between that relative claim and the absolute latency a real-time system needs.
Being the fastest GPT-5.6 does not make a model fast enough.
The next frontier is intelligence per second
GPT-5.6 Luna did not fail BulletBench because it was incapable of playing chess. It failed because too much of its capability was trapped behind latency.
Gemini 3.1 Flash Lite remains the fast-format all-rounder for the opposite reason. It is not the deepest thinker on the board. It is the model that most reliably turns the intelligence it has into a move before the clock runs out.
The model that finally displaces it will have to do both. It will need to play materially better than today's tiny fast models and finish materially more often than today's reasoning models. It will need frontier-model judgement with the latency discipline of infrastructure.
That is the open square in the market.
Until someone fills it, the same supposedly modest model that has been near the top since BulletBench went live will keep surviving newer, smarter releases for one unglamorous reason: it answers in time.
Explore every rating, latency distribution and replay on the live BulletBench leaderboard. If you want to see the same quality, cost and latency trade-off measured on your own prompts, join Spring Prompt.
