![\"Two](\"https://cdn.prod.website-files.com/6ace8efc702b317d7a00de10/6ae14ba7d6ca5d658214913a_6ae14ad84c5ad4ffb2f2aa3c_particle-1-cascade-updated.svg\")
Particle team · October 28, 2026
\nToday, we’re launching Particle to make highly optimized intelligence accessible to everyone. The cost of using capable models still limits who can use them, how often, and what they can build. We’re working to lower that cost by training models to solve problems more efficiently, so people can deploy more intelligence to solve more problems.
\nParticle-1, post-trained on DeepSeek V4.1 Flash,** sees large improvements in token efficiency using around ~45% fewer tokens on average across a wide variety of tasks.** Many improvements in token optimization only improve on reducing costs but, in this case, tasks finish sooner which is good for end-users. We trained the model in reinforcement learning environments developed internally, with the goal of solving tasks with fewer tokens while maintaining accuracy.
\nThis first release focuses on software engineering. We plan to bring Particle to other domains in future releases.
\n| Model | Cost (USD per task) | Mean output tokens per task | Task pass rate |
|---|---|---|---|
| Particle-1 | $0.2211 | 59,580 | 72.57% |
| DeepSeek V4.1 Flash | $0.3368 (1.5x) | 83,246 (1.4x) | 71.15% |
| GLM 5.3 Flash | $0.6523 (3.0x) | 98,155 (1.6x) | 66.82% |
Our reward function incentivizes the model to solve tasks successfully while using fewer tokens for reasoning and tool calls. We evaluated Particle-1 on four benchmarks<sup>a</sup>:
\nAcross these benchmarks, Particle-1 uses 28.4%–52.2% fewer output tokens and achieves 34.4%–51.6% lower average cost per task<sup>b</sup> than DeepSeek V4.1 Flash. Pass@1 rates are within the confidence intervals of the base model.
\nOn general benchmarks outside our training domains, Particle-1’s accuracy stays close to base DeepSeek V4.1 Flash: 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%).
\nThe graph shows token savings across two stages of RL training, up to the peak of the smoothed curve. For each rollout group, we compare the mean assistant-token count with the task’s fixed baseline, then average these reductions equally across groups. Higher percentages mean fewer tokens used.
\nThe discontinuity marks the start of stage 2, when the training set shifted mainly toward data engineering. Although stage 1 focused entirely on coding, the model was already using about 20% fewer tokens on data engineering tasks compared with their baselines. This was our first glimpse of generalization.
\nTo train Particle-1, we built an internal collection of coding and data engineering tasks in Harbor format with our autonomous synthetic data system called Datamaker. Each environment gives the model a problem to solve through the Terminus 2 agent and a way to verify the outcome. This process helped us internally validate that our data pipeline could construct generalizable tasks.
\nWe split post-training into successive stages, following the Cascade RL approach. This structure let us focus training on different task domains in sequence.
\nOur training infrastructure is built on Miles, RadixArk’s open-source RL framework, with distributed asynchronous training and dedicated rollout and trainer nodes. We made multiple optimizations to the SGLang rollout engine and the Megatron training engine to maximize throughput for our workload and reduce trainer-inference mismatch.
\nWe trained a rank-64 LoRA adapter covering the experts in all layers (Schulman et al.). Its trainable parameters are equivalent to about 1.25% of the model’s parameter count.
\nFor the policy update, we used Group Sequence Policy Optimization (GSPO) which applies importance weighting and clipping to each sequence as a whole, not to individual tokens. In our experiments, training with a token-level loss oscillated and eventually diverged. We kept the learning rate constant at 5e-5 and following Dr. GRPO, did not normalize advantages by the group's standard deviation.
\nTo better understand the gains in token efficiency and uncover potential issues, we analyzed trajectories from both the base model and our post-trained model. We compared runs on the same task and seed where both models passed, looking at how their reasoning, actions, and verification differed. Four common patterns emerged.
\nReasoning tokens account for roughly 90% of the token savings on Terminal-Bench 2.1, ReactBench, and ADE. On DeepSWE 1.1, tool-call text also contributes around 30% of the savings.
\nHere are some example rollouts across the benchmarks.
\nTerminal-Bench 2.1
\n66.2% fewer output tokens
\nParticle-1: 15,892
\nDeepSeek V4.1 Flash: 47,006
\nParticle-1 used much less reasoning around deployment checks and completion, reducing output from 43,907 to 14,840 tokens, despite making slightly more model calls. The final two confirmation calls alone dropped from 11,445 to 1,765 tokens, while both runs successfully verified the branch deployments.
\nTerminal-Bench 2.1
\n60.4% fewer output tokens
\nParticle-1: 6,766
\nDeepSeek V4.1 Flash: 17,070
\nParticle-1 inspected the Makefile and selected its build flags before compiling, while the base model revisited the flags, rebuilt, and repeated installation and verification. Avoiding that additional cycle helped reduce the trajectory from 18 to 12 model calls and 15,436 to 6,503 output tokens.
\nTerminal-Bench 2.1
\n54.8% fewer output tokens
\nParticle-1: 4,977
\nDeepSeek V4.1 Flash: 11,023
\nBoth models produced the correct calendar event using four model calls and six commands, so the gain came from shorter reasoning rather than fewer actions. Approximately 94% of the token savings occurred after the correct file had already been written, with completion and confirmation shrinking from 5,193 to 1,078 tokens.
\nDeepSWE 1.1
\n37.8% fewer output tokens
\nParticle-1: 52,545
\nDeepSeek V4.1 Flash: 84,413
\nParticle-1 completed the implementation and regression checks with fewer subsequent edge-case, documentation, and formatting rounds, using 68 model calls versus 111. Output dropped from 77,362 to 51,186 tokens.
\nDeepSWE 1.1
\n34.9% fewer output tokens
\nParticle-1: 52,933
\nDeepSeek V4.1 Flash: 81,327
\nParticle-1 began editing on call 11 versus call 20 and spent fewer later rounds revising dependency discovery, reducing output from 84,971 to 51,293 tokens. Both passed their local test suites.
\nDeepSWE 1.1
\n35.9% fewer output tokens
\nParticle-1: 69,240
\nDeepSeek V4.1 Flash: 108,016
\nParticle-1 began implementation on call 29 versus call 43, while the base model performed more preliminary Git experiments and later edge-case repairs, including repeating a manual test suite 20 times. The trajectory shrank from 118 to 86 calls and 105,837 to 67,216 tokens.
\nReactBench
\n52.2% fewer output tokens
\nParticle-1: 29,099
\nDeepSeek V4.1 Flash: 60,885
\nThe base model spent several turns repairing patch application problems involving working directories, heredocs, and string matching, while Particle-1 reached a working patch with fewer repair attempts and retained targeted navigation tests. Together with shorter completion reasoning, this reduced the run from 43 to 29 model calls and 60,468 to 27,848 output tokens.
\nReactBench
\n47.5% fewer output tokens
\nParticle-1: 49,249
\nDeepSeek V4.1 Flash: 93,848
\nParticle-1 spent less reasoning on implementation choices and made fewer successive revisions to path handling and fallback behavior, while still probing recursive traversal and multi-batch file drops. Output fell from 86,657 to 53,478 tokens, even though Particle-1’s final confirmation was longer; the savings came earlier in implementation, where the base model also explored potentially useful refinements.
\nReactBench
\n43.5% fewer output tokens
\nParticle-1: 37,054
\nDeepSeek V4.1 Flash: 65,564
\nParticle-1 attempted its first patch on call 12, compared with call 27 for the base model, and obtained type-checking feedback earlier instead of extending the initial inspection. It also shortened the final confirmation from 10,589 to 662 tokens, contributing to a total reduction from 64,012 to 32,274 tokens.
\nADE Bench
\n62.1% fewer output tokens
\nParticle-1: 9,235
\nDeepSeek V4.1 Flash: 24,344
\nParticle-1 reused the existing surrogate-key macro, while the base model implemented an incrementing key with additional bookkeeping and incremental validation; the main edit call used 1,602 versus 8,722 output tokens. This saved design and implementation effort, but the key-generation semantics differed, so the savings also reflect a different solution rather than merely a shorter explanation of identical work.
\nADE Bench
\n45.1% fewer output tokens
\nParticle-1: 6,900
\nDeepSeek V4.1 Flash: 12,570
\nBoth models implemented the same three staging-layer casts, but Particle-1 used 1,757 tokens for the edit call compared with 3,485 for the base model. Total output fell from 9,352 to 5,643 tokens despite Particle-1 making 15 rather than 13 calls, locating the gain primarily in shorter reasoning around the same fix.
\nADE Bench
\n61.4% fewer output tokens
\nParticle-1: 3,180
\nDeepSeek V4.1 Flash: 8,235
\nParticle-1 inspected the schema and used the correct milliseconds column immediately, while the base model initially used lap_time_in_ms and needed a correction. Particle-1 also reduced final confirmation from 3,519 to 198 tokens, which accounted for approximately 48% of this pair’s total token savings.
Although our post-training focused on coding and data engineering, we’re seeing early signs that the token-efficient behavior carries over to other domains, including legal work and cybersecurity.
\nFor illustration, we gave Particle-1 a contract-review task from Harvey LAB<sup>e</sup>. The agent reads four legal documents, checks whether an arbitration clause complies with the arbitration institution’s rules, and writes a Word report flagging each deviation, its severity, and a recommendation. We also scaled the strength of Particle-1’s LoRA adapter from 0.25× to 8× to see how the behavior changes as its effect grows.
\nHarvey LAB
\n24.6% fewer output tokens
\nThe standard Particle-1 adapter strikes the best balance in this sweep. Its reports keep the explicit comparisons, caveats, and recommendations a complete answer needs, while using about a quarter fewer tokens than the base model.
\nDeepSeek V4.1 Flash spent the most tokens, writing long reports and checking them repeatedly, but that extra work didn’t reliably produce complete answers. At the standard 1× strength, Particle-1 used 24.6% fewer output tokens than the base model, and all eight of its reports passed every criterion under both judges. Stronger settings cut output further, by 47.8% at 2× and 60.2% at 4×, with one or two reports each missing a single criterion. At 8×, output fell by 78.7%, but only three of eight reports passed the strict check. The misses suggest that aggressive scaling compresses useful qualifications along with redundant analysis.
\nThese early results make Particle-1 a promising foundation for adding new capabilities while keeping costs significantly low.
\nParticle-1 is available today through the Particle API. Sign up for an API key and plug Particle-1 into your own harness or agent workflow. The docs walk you through connecting it.
\n\na. All four benchmarks use the Terminus 2 agent, a 512k-token limit, temperature 1, top_p 0.95, and max reasoning. Terminal-Bench 2.1 excludes the fastText task.\nb. Prices per million tokens for uncached input, cached input, and output (including reasoning) are $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.\nc. Costs average all attempts, including failures, at a fixed 95% cache hit rate. Blended input rates are $0.0207 per million tokens for Particle-1 and DeepSeek, and $0.0360 for GLM. All prices are in USD.\nd. Mean tokens is the average number of assistant-generated tokens across all valid rollouts, including successful and unsuccessful attempts. Rollouts interrupted by infrastructure issues are excluded. Each model generated 16 rollouts per task.\ne. The Harvey LAB comparison covers one task with eight rollouts per setting, max reasoning, a 131,072-token per-call limit, and a 512,000-token total output budget.
\nOriginally published at the Particle blog.
","headings":[{"level":2,"text":"Fewer tokens with comparable accuracy","id":"fewer-tokens-with-comparable-accuracy"},{"level":2,"text":"Scaling RL for token efficiency","id":"scaling-rl-for-token-efficiency"},{"level":3,"text":"Asynchronous training stack","id":"asynchronous-training-stack"},{"level":2,"text":"Where the token savings come from","id":"where-the-token-savings-come-from"},{"level":3,"text":"Git deployment","id":"git-deployment"},{"level":3,"text":"pMARS build","id":"pmars-build"},{"level":3,"text":"Calendar scheduling","id":"calendar-scheduling"},{"level":3,"text":"cattrs partial recovery","id":"cattrs-partial-recovery"},{"level":3,"text":"Awilix async startup","id":"awilix-async-startup"},{"level":3,"text":"go-git merge conflicts","id":"go-git-merge-conflicts"},{"level":3,"text":"CoreUI navigation","id":"coreui-navigation"},{"level":3,"text":"Recursive file drops","id":"recursive-file-drops"},{"level":3,"text":"Table row selection","id":"table-row-selection"},{"level":3,"text":"Review primary key","id":"review-primary-key"},{"level":3,"text":"String product IDs","id":"string-product-ids"},{"level":3,"text":"F1 lap-time model","id":"f1-lap-time-model"},{"level":2,"text":"Generalization beyond coding","id":"generalization-beyond-coding"},{"level":3,"text":"Arbitration clause audit","id":"arbitration-clause-audit"},{"level":2,"text":"Build with Particle","id":"build-with-particle"},{"level":3,"text":"Notes","id":"notes"}]}}