This week, OpenAI slashed Luna (GPT-5.6) pricing by 80% — from $7 to $1.40 per million tokens. Anthropic shipped Opus 5 at half the price of its predecessor. The LLM API market is in a genuine price war, and for once, developers are winning.
I should be celebrating. I'm not. Here's why.
The hidden math of cheaper models
When official API prices drop, the economics of model-swapping change in a way nobody talks about.
A bad relay has a simple business model: bill you for Model X, serve you Model Y, pocket the difference. When Model X costs $15/M tokens and Model Y costs $0.15/M, the margin is $14.85. That's already attractive.
When Model X drops to $1.40? The absolute margin shrinks — and that's what most people see. But the relative margin — the ratio of what you're charged vs what's actually served — can actually grow if budget models get cheaper still. And they have.
The point isn't the exact math. The point is: price competition between legitimate providers doesn't eliminate the incentive to swap models. It often masks it. When everyone's prices are dropping, a relay that's 30% cheaper than official looks like aggressive discounting, not fraud.
"What model are you?" doesn't work
If you're still asking an API endpoint to identify itself, stop. That's a system prompt — trivially spoofed. Every relay operator knows to make the model say "I am Claude, created by Anthropic."
What works: behavioral fingerprinting at temp=0.
Give the model a fixed set of tasks that different models handle differently — reasoning problems, long-context recall, strict JSON formatting, refusal boundaries. Run them at temperature 0 to remove sampling noise. Diff the results against the official API.
This isn't theoretical. Here's the actual tool:
git clone https://github.com/seven7763/llm-honesty-probe
cd llm-honesty-probe
python3 -m llm_honesty_probe --self-test --card
That runs a battery of deterministic probes and produces a verdict card: PASS, SUSPICIOUS, or DEGRADED — with the specific probes that triggered each finding. No API key leaves your machine. No judgment calls required. The self-test runs without any API key and takes about 30 seconds.
To test your actual endpoint:
export LLM_ENDPOINT="https://your-endpoint/v1"
export LLM_API_KEY="sk-your-key"
python3 -m llm_honesty_probe --compare
Why this matters more now, not less
The price war is genuinely good news. Lower costs mean more experiments, more products, more people who can afford to build with LLMs. I want all of that.
But cheaper official APIs also mean more users signing up for the first time — users who don't know what "Claude" is supposed to sound like, what GPT-5.6's reasoning depth should feel like, or what latency to expect. These are exactly the users a model-swapping relay wants: no baseline for comparison.
The defense isn't trust. It's verification that costs less than being wrong.
Test your endpoint right now
If you're using any third-party API endpoint — mine included — run the probe. The self-test takes 30 seconds. The compare against your endpoint takes about 2 minutes.
If everything passes, you've got evidence — not proof, but signals — that you're getting what you pay for. If something flags, you know exactly which probe to investigate.
Either way, you know more than you did before. That's the whole point.
Disclosure: I work on daoxe, an OpenAI-compatible LLM gateway. I also maintain llm-honesty-probe, the open-source tool mentioned in this post. The probe treats every endpoint identically — including daoxe. Point it at anyone. If it flags something on my own service, I want to know before you do.
The price war is real. The trust problem is real. They're related, and fixing one doesn't automatically fix the other.
Top comments (0)