By Sean Donahoe · Published November 20, 2026. Lane prices on this page are the "from" rates. Exact input and output rates are on the pricing page.
Gemini 4 Neon shipped on November 19, and somebody reading this is about to rewire their whole app around it.
Don't. Not yet, anyway.
It went live on Flux Router on every paid key, and GPT-6.2 Sol and GPT-6.2 Astra landed the same week. Every launch drags the same question back up: do you let the router choose a model for each request, or do you pick one yourself and lock it in?
Should I let the router pick, or pin the model?
Both, in very unequal amounts.
Send the bulk of your traffic to flux-auto. Pin the handful of calls where one specific model clearly does the job better. Then go back and look at those pins again whenever new models land, because a pin that made sense a few launches ago can be the wrong call today.
The rest of this page is the why, plus how I'd test Neon.
What does flux-auto do when it picks?
flux-auto is the default, and it's where I'd tell anyone to start (I built the thing, so discount that however you like). A classifier reads each prompt and works out what kind of job it is, then sends it to a lane. Light prompts go to Fast, harder ones go up to the higher lanes. Inside the lane, a learning router chooses among models that are equivalent on quality for that kind of work.
Fast is priced from $1 per million tokens, Standard from $2, Reasoning from $4.
Here's the bit people skim past, and it's the reason auto should carry most of your traffic. flux-auto bills at the Standard rate, or at the Fast rate when it sends the request to Fast and a Fast model answers. It never bills more than Standard. Even when some monster of a prompt gets pushed all the way up to the Reasoning lane, you pay Standard for it. So you know the highest rate you'll pay before you send a single token, and the easy stuff comes in under it.
You can also skip the classifier and aim at a lane yourself with flux-fast, flux-standard or flux-reasoning (there's a flux-image lane too). Each one bills its own lane rate. If you already know a job is simple, a tagging loop or a pile of short rewrites, send it to flux-fast and you pay the Fast rate every time. The flip side: flux-reasoning bills the Reasoning rate every time, which is above auto's Standard ceiling.
A lane is still the router picking, mind you. All you've decided is the tier.
So when does pinning make sense?
Pinning means one exact model, by name, on every call. Flux carries 50+ models, each with a flux-pinned-* alias (flux-pinned-gemini-4-neon, for example), and the models page or GET /v1/models (client.models.list() in the SDK) gives you the live list.
Two things change when you pin.
The price, first. A pinned call bills at that model's provider rate plus 12%, so what you pay depends entirely on which model you chose. There's no Standard ceiling sitting over it.
And the model stops moving. flux-auto and the lane aliases pick up model improvements without you touching your code. A pinned alias stays on that exact model until you change it yourself. Most of the time that works against you, but for a few kinds of call it's exactly what you want:
- Evals and regression tests. If the model under the test can change, a failing test tells you nothing about your own code.
- One model has a strength you depend on. A long context window, say, or a tool-calling quirk your agent was built around.
- Compliance or vendor reasons. Somebody signed a piece of paper saying which provider handles this data, and that's the end of the discussion.
- You're testing a new model against the one you run now.
If a call doesn't fit one of those, I wouldn't pin it. "I like this model" isn't on the list (I have favorites too, it's still not a reason).
A pinned request still goes through the same metered gateway, on the same key, with the same usage reporting as everything else. Pinning a few calls doesn't mean a second integration.
Testing Neon against what you run now
That's reason four on the list, and the one that matters right now.
Neon is new, and I have no idea whether it's better for your workload. Neither does anybody's launch announcement. Finding out costs you one string, though. One catch: pinned aliases need a paid key, so add credit on the pricing page first if you're still on the starter credit.
If you're on the OpenAI SDK, Flux is a base URL and a key:
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.fluxrouter.ai/v1",
api_key=os.environ["FLUX_API_KEY"],
)
resp = client.chat.completions.create(
model="flux-auto", # the router picks
messages=[{"role": "user", "content": "Summarize this ticket in two sentences: ..."}],
)
print(resp.choices[0].message.content)
Pinning Neon is that same call with one line changed:
model="flux-pinned-gemini-4-neon", # exactly this model, every call
(Anthropic clients use https://api.fluxrouter.ai/anthropic as the base URL. Same key.)
Now run both over a batch of your real prompts. I mean the ugly production ones, with the weird formatting and the customer who types in all caps, because somebody else's benchmark won't tell you much about those.
prompts = [...] # real ones, pulled from your own logs
for p in prompts:
for model in ("flux-auto", "flux-pinned-gemini-4-neon"):
resp = client.chat.completions.create(
model=model,
messages=[{"role": "user", "content": p}],
)
print(model, "|", resp.choices[0].message.content or "")
print("-" * 40)
Read the outputs next to each other. Where Neon clearly wins on a particular job, pin that job. Everything you can't tell apart stays on auto, and you get on with your day.
"Clearly wins" takes actual reading, no shortcut there. The calls themselves bill pay as you go on the tokens you use, input plus output, with no seats and no minimums, so the experiment costs what those test calls cost.
The easy button
Don't feel like auditing your own model strings? Hand this to your coding agent:
This app calls Flux Router (https://api.fluxrouter.ai/v1) through the OpenAI SDK.
1. List every place we set a model name and propose "flux-auto" for each.
Don't change anything yet.
2. Flag only the calls where one exact model matters: eval or regression
tests, long-context jobs, tool calling that depends on one model's
behavior, or compliance/vendor rules that name one provider. For those, suggest a flux-pinned-* alias from GET /v1/models,
put it in a named constant, and add a comment saying why it is pinned.
3. Add a small script that runs a list of my prompts through "flux-auto"
and "flux-pinned-gemini-4-neon" and prints the outputs side by side.
Do not pin anything else.
Re-check your pins when models land
Which lately is a lot.
This is the cost of pinning that never shows up on an invoice. Auto and the lanes improve without you doing anything, and a pin sits exactly where you left it. The model you chose because it was the best at your extraction job is still answering that job today, whether or not it's still the best at it. You get no error and no alert when it gets overtaken. The responses keep coming back looking fine.
So keep the pins few enough that you can list them from memory, write down why each one exists, and rerun the comparison above when something new shows up. Neon, Sol and Astra all showed up in the same week.
If a pin can't win its own rerun, delete it and let that call go back to auto. My guess is most people come out of that exercise with fewer pins than they went in with, and maybe one new one with Neon's name on it. New to Flux? The quickstart gets you a key, and the pricing page is where you add credit for pinned models.
