Particle-1: A DeepSeek V4.1 Flash Tune That Claims 45% Fewer Output Tokens

Particle-1 is a new coding model that claims to do the same work as DeepSeek V4.1 Flash with roughly 45% fewer output tokens. Startup Particle launched it on October 28, 2026 with an announcement post and a listing on OpenRouter. The pitch is simple: if a model thinks less and stops sooner, tasks finish faster and cost less, as long as accuracy holds.

Everything below the headline comes from Particle's own post. We have not reproduced any of it, so read the numbers as claims worth testing rather than settled results. That framing matters because token-saving fine-tunes can look great on selected benchmarks and fall apart on your real codebase.

TL;DR: claimed versus verified

What did Particle actually build?

Small shape reaching for a green token, picturing reinforcement learning rewards for fewer-token coding answers

Particle says it trained Particle-1 "in reinforcement learning environments developed internally, with the goal of solving tasks with fewer tokens while maintaining accuracy." The reward function pays for solving the task successfully while using fewer tokens for reasoning and tool calls. The base is DeepSeek V4.1 Flash, the open-weight model we covered in DeepSeek V4.1 Flash 1017: MIT weights and Terminal-Bench numbers.

The training recipe, as Particle describes it:

• Environments: an internal collection of coding and data-engineering tasks in Harbor format, built by what Particle calls an autonomous synthetic data system named Datamaker. Each task has a way to verify the outcome, and the agent harness is Terminus 2.
• Stages: training ran in successive stages following the Cascade RL approach. Stage one was all coding; stage two shifted mainly to data engineering.
• Method: a rank-64 LoRA adapter over the experts in all layers, with trainable parameters equal to about 1.25% of the model, and GSPO as the policy-update method. Particle says token-level loss oscillated and eventually diverged in its experiments.
• Infrastructure: the open-source Miles RL framework from RadixArk, with optimizations to the SGLang rollout engine and the Megatron training engine.

Because the whole change is a LoRA adapter, the behavior can be scaled. Particle uses that in a side experiment, described below.

What are the benchmark claims?

Particle evaluated on four benchmarks, all with the Terminus 2 agent, a 512k-token limit, temperature 1, top_p 0.95, and max reasoning, with 16 rollouts per task:

• Terminal-Bench 2.1: terminal workflows such as compiling software, debugging, and configuring systems.
• ReactBench: building and fixing React applications.
• ADE Bench: analytics and data engineering using real dbt projects.
• DeepSWE 1.1: longer software-engineering tasks across real codebases.

Across them, Particle reports 28.4% to 52.2% fewer output tokens and 34.4% to 51.6% lower average cost per task than DeepSeek V4.1 Flash, with pass@1 inside the base model's confidence intervals. In its summary chart Particle also compares against GLM 5.3 Flash. The figures shown there, per Particle, are:

Source: Particle's launch post. Averages include failed attempts, with costs computed at a fixed 95% cache hit rate. Note that a 1.4 percentage point pass-rate edge for Particle-1 is described by Particle itself as within confidence intervals, so the fair reading is "no measurable accuracy loss", not "more accurate".

On benchmarks outside its training domains, Particle reports accuracy stays close to the base: GPQA Diamond 90.40% (base 90.91%), Tau Airlines 86.00% (base 88.00%), Standard MMLU 86.08% (base 85.98%), and BabyVision with tools 89.18% (base 89.60%). The Tau Airlines gap of two points is the largest of the four, and it is the closest thing in the post to an agentic non-coding test.

Glass jar with few dots left, showing Particle-1 token budget savings versus DeepSeek V4.1 Flash

Where do the savings come from?

Particle compared trajectories where both models passed on the same task and seed, and describes four patterns: less reasoning for the same actions, stopping once the task is complete, fewer rounds of trial and repair, and more focused exploration and verification. By its measurement, reasoning tokens account for roughly 90% of the saving on Terminal-Bench 2.1, ReactBench, and ADE Bench. On DeepSWE 1.1, tool-call text contributes about 30%.

The examples in the post are concrete. In a git deployment task, Particle-1 used 66.2% fewer output tokens, and the final two confirmation calls alone dropped from 11,445 to 1,765 tokens. In a calendar task both models made four calls and ran six commands, and about 94% of the savings came after the correct file was written, which means the saving was mostly shorter confirmation text. In ADE Bench, the 62.1% saving on one task reflected a different solution, because Particle-1 reused an existing macro while the base model wrote custom key logic. Particle says plainly that the saving there reflects "a different solution rather than merely a shorter explanation of identical work".

That honesty is useful. It tells you a share of the headline is stop-earlier behavior (trimmed summaries, fewer re-checks), and a share is a different engineering choice. Whether the shorter path is better depends on your repo. Particle notes that "extra tests and documentation can still be useful", so a model that skips them saves tokens by doing less verification.

Does it generalize beyond code?

Particle shows one early test outside coding: a contract-review task from Harvey LAB, where the agent reads four legal documents, checks an arbitration clause against institutional rules, and writes a Word report. It also scaled the adapter strength from 0.25x to 8x.

At the standard 1x setting, Particle reports 24.6% fewer output tokens than the base model and all eight reports passing every criterion under both judges, against a base accuracy of 62.5% on that single task. Stronger settings cut more: 47.8% at 2x and 60.2% at 4x, but with one or two reports each missing a criterion, and at 8x output fell 78.7% while only three of eight reports passed the strict check. Particle's own interpretation is that aggressive scaling "compresses useful qualifications along with redundant analysis."

This is one task with eight rollouts per setting, so it is an illustration, not evidence. Still, the sweep reveals the trade-off clearly: token savings are a dial, and the further you turn it, the more the model skips.

Pricing: the launch post and the listings do not match

Particle's launch post gives prices per million tokens for uncached input, cached input, and output (including reasoning): $0.30, $0.006, and $1.20 for both Particle-1 and DeepSeek V4.1 Flash, and $0.15, $0.03, and $0.50 for GLM 5.3 Flash. That is how it concludes cost per task falls with token count.

OpenRouter's Particle-1 listing shows $0.25 per million input tokens, $1 per million output tokens and $0.03 for cache reads, with a 1,048,576-token context window. The two sets of numbers differ. Possible explanations include a different provider route or a promotional rate, but neither source says. Before you budget, check the live price on the provider you will call, and compute your own cost per task rather than reusing Particle's 95% cache-hit assumption. If your agent harness caches less, input cost matters more and the savings shrink.

What should you test before switching?

A cost-per-task claim is only as good as the benchmark's resemblance to your workload. Here is a practical plan:

1. Pick 20 to 50 real tasks from your repo history that have tests, not synthetic prompts.
2. Run both models with your harness, same temperature, and same budget, with several rollouts each.
3. Measure pass rate, output tokens, wall-clock time, and cost including failures, as Particle does.
4. Read failures by hand. Look for skipped tests, missing docs, or stripped error handling that the base model would have added.
5. Check long-horizon behavior. Token savings that come from stopping early can hurt on tasks needing deeper verification.
6. Re-run on updates. Particle plans further releases, so pin the exact model ID in your harness.

If your pipeline already pays attention to token spend, this fits a wider pattern. See our look at code-review-graph, which cuts agent token use by not re-reading the repo, and the efficiency-by-training angle in Rigel, a 2.3B model matching Llama-3.2-3B with under 1% of the pretraining compute.

How does it fit the DeepSeek V4.1 Flash ecosystem?

The base model has become a popular substrate. We have covered its open weights and Terminal-Bench numbers, an incident in which a DeepSeek V4.1 Flash agent was caught cheating on a bug hunt, a cyber-index claim in Artificial Analysis cyber index 57%: claimed versus verified, and its free tier in OpenCode's Zen and Go limits.

Two lessons carry over to Particle-1. First, a model that optimizes hard against a reward can find shortcuts, so token-reward training deserves scrutiny for behaviors like skipping verification. Particle's own trajectory analysis acknowledges this risk when it says it examines "what each run delivers when interpreting the savings." Second, a thin adapter on a strong base inherits the base's strengths and its weaknesses: if V4.1 Flash struggles on your language or framework, Particle-1 will too.

What is verified and what is not?

Verified from primary pages: Particle published the launch post with the figures above, and the model is listed on OpenRouter. Not verified: the benchmark results, the 45% average, the cost-per-task figures, the generalization claim, and any independent reproduction. We found no third-party evaluation at publication time. The wide range from 28.4% to 52.2% itself signals that results will vary by task type.

Bottom line

Particle-1 is an interesting bet: instead of making a model smarter, make it terser, and sell the saving. If Particle's numbers hold, a 34% to 52% lower cost per task at unchanged per-token price is meaningful for teams running long agent loops on cheap models. The evidence so far is one company's evaluation on its own harness. Test it on your tasks, watch for skipped verification, and re-check pricing on the provider you use.

Related reading

• DeepSeek V4.1 Flash 1017: MIT weights and benchmarks
• DeepSeek V4.1 Flash caught cheating on a bug hunt
• Artificial Analysis cyber index claim for DeepSeek V4.1 Flash
• OpenCode and DeepSeek V4.1 Flash free limits
• code-review-graph: stop agents re-reading your repo
• Rigel: a 2.3B model with under 1% of the pretraining compute
• Official: Introducing Particle-1 and the OpenRouter listing

Figures are Particle's self-reported results as of October 29, 2026 and may change.