Meta description: Particle-1, a DeepSeek V4.1 Flash post-train launched October 28, claims 28.4% to 52.2% fewer output tokens on coding tasks. Here is what that does and doesn't mean for cost.
Suggested tags: Particle-1, DeepSeek V4.1 Flash, coding models, token pricing, OpenRouter
Particle-1 Says It Codes With 45% Fewer Tokens—Why That Doesn't Automatically Mean 45% Off Your Bill
On October 28, 2026, a new company called Particle announced itself and its first model in the same breath. The company is the latest venture from Suhail Doshi, the Mixpanel founder, and the model is Particle-1: a coding model post-trained on DeepSeek V4.1 Flash, available through an API from day one and listed on OpenRouter the same day.
The pitch is one sentence long: same work, fewer tokens. Particle says Particle-1 finishes coding and data-engineering tasks with far less reasoning and tool-call output than its base model, and in an industry that bills by the token, fewer tokens is the whole business model.
We have not called the API or run the model ourselves. Everything below comes from Particle's launch materials and its OpenRouter listing, and is worth reading as claims to test rather than settled facts.
What Particle is claiming
The headline number is about 45% fewer output tokens on average. Broken down across the four coding and data-engineering benchmarks Particle ran, the reduction ranges from 28.4% to 52.2% compared with the base DeepSeek V4.1 Flash. Accuracy, measured as pass@1, reportedly stays within the base model's confidence intervals.
From tokens, Particle moves to money: the company says average cost per task came in 34.4% to 51.6% lower than the base model.
How did they get there? The short version: reinforcement learning in internal coding and data-engineering environments, where the reward pays for solving the task while spending fewer tokens on reasoning and tool calls. Technically it is a rank-64 LoRA adapter touching about 1.25% of the model's parameters—so this is a tune of an existing open model, not a new foundation model. That matters for how you read the claims: the question is never "is this the best model," it is "is this a better way to run this particular model."
Why price per token and cost per task are different numbers
This is the part worth slowing down for, because it is the point of the whole launch.
When you compare models on a pricing page, you compare dollars per million tokens. But an agentic coding task is not a fixed number of tokens. It is a loop: read the repo, plan, call a tool, read the result, reason some more, edit, run the tests, fail, retry. Every lap around that loop spends output tokens, and at typical price ratios—output costing roughly four times input—those tokens are where the bill lives.
So two models with identical prices per token can produce very different bills for the same task. If one of them gets to the same passing solution in half the output tokens, the task really does cost about half as much. That is the mechanism behind Particle's pitch, and it is real.
The flip side is also real: the savings only exist if the passing solution keeps passing. A model that stops early, skips a test run, and hands you code that fails CI has not saved you 45%—it has cost you a retry loop, a human review, or a broken deploy. Token counts are easy to measure. Whether the work still clears your bar is the part you have to check.
The caveats, in plain terms
These are the company's own numbers. Particle ran the benchmarks, picked the tasks, and reported the results. Nobody has independently reproduced them at the time of writing. That does not make them wrong; it makes them a starting point.
The cost math assumes a 95% cache hit rate. Particle's per-task savings are computed with a fixed 95% cache-read assumption. Cached input is far cheaper than fresh input, so a high hit rate shrinks the input side of the bill and makes the output-token savings loom larger. If your harness caches less aggressively—many do—input costs grow, and the percentage you save shrinks. Your number will not be their number.
The prices don't match across sources. Particle's launch post lists $0.30 per million uncached input tokens, $0.006 cached, and $1.20 output—the same rates it quotes for the base model, which is what makes the token-count math translate directly into cost math. OpenRouter's listing shows different numbers: $0.25 input, $1.00 output, and $0.03 for cache reads per million tokens, on a 1M-token context window. Neither page explains the difference. Before you budget anything, look up the live price on the route you will actually call, and redo the arithmetic with your own cache rate.
Savings are a dial, and the far end of the dial costs quality. Particle ran a side experiment on a contract-review task, scaling the adapter's strength up from 1x to 8x. At the standard setting the model used 24.6% fewer tokens and passed every check. Cranked to 8x, output dropped 78.7%—but only three of eight reports still passed. Particle's own reading is that aggressive settings "compress useful qualifications along with redundant analysis." That is the honest summary of the whole approach: fewer tokens is good right up to the point where the model starts skipping things you needed.
Availability has edges. On OpenRouter the model is served by a single provider and is not currently available through EU in-region routing—which is a routing limitation, not a statement that European users cannot call it at all. And while the base model is open-weight, Particle has not announced weights for Particle-1; for now it is API-only.
How to test it properly if you're curious
The evaluation that matters is not Particle's benchmark suite—it is yours. The recipe is simple enough:
Take a handful of real tasks from your own backlog, the kind you actually hand to an agent. Run them on DeepSeek V4.1 Flash and on Particle-1 with the same harness, the same tools, and the same tests as the judge. Then compare two numbers: the total billed cost per task at the prices you actually pay, and the pass rate against your own bar, not theirs.
If Particle-1 comes in cheaper and the output still passes, you have found real savings. If it comes in cheaper but the failures creep up, the token savings were the easy part to measure, not the important part.
The bottom line
Particle-1 is an interesting bet: that the next lever on AI coding costs is not a cheaper model, but a model that talks less. The claimed numbers—28.4% to 52.2% fewer output tokens with accuracy inside the base model's confidence interval—would matter if they hold up outside the launch post. But a price per million tokens was never the cost of getting a task done, and a self-reported benchmark was never your bill. The only evaluation that answers either question runs on your tasks, with your tests, against your invoice.