Particle-1 Launches: A DeepSeek V4.1 Flash Post-Train That Particle Says Uses 28-52% Fewer Output Tokens on Coding Benchmarks

Particle, a new company from Mixpanel co-founder Suhail Doshi, launched on Oct. 28 with Particle-1: DeepSeek V4.1 Flash post-trained with reinforcement learning to finish software tasks using fewer tokens. The pitch isn’t a cheaper token. It’s a cheaper finished task. In Particle’s own cost table, Particle-1 and its base model pay the same per-token prices. Any savings come from the model writing less.

That makes this a useful test case for anyone who budgets coding agents by cost per completed task instead of $/MTok. Every benchmark figure below comes from Particle. None has been independently replicated yet.

What Particle reports

Particle evaluated four agentic benchmarks: Terminal-Bench 2.1, ReactBench, ADE Bench (dbt and data engineering) and DeepSWE 1.1. All four ran on the Terminus 2 agent with a 512k-token limit, temperature 1, top_p 0.95 and max reasoning, with 16 rollouts per task. Pooled results from the launch post:

Model	Cost per task	Mean output tokens per task	Pass rate
Particle-1	$0.2211	59,580	72.57%
DeepSeek V4.1 Flash	$0.3368	83,246	71.15%
GLM 5.3 Flash	$0.6523	98,155	66.82%

Across the individual benchmarks, Particle says Particle-1 used 28.4% to 52.2% fewer output tokens and cost 34.4% to 51.6% less per task than DeepSeek V4.1 Flash. It also says pass@1 rates stayed within the base model’s confidence intervals. On general benchmarks outside its training domains, accuracy stayed close to the base model. GPQA Diamond came in at 90.40% vs 90.91%, Tau Airlines at 86.00% vs 88.00% and MMLU at 86.08% vs 85.98%.

The cost column depends on two assumptions you need to know before you compare it with your own bill. Particle priced both Particle-1 and DeepSeek V4.1 Flash at $0.30 per million uncached input tokens, $0.006 cached and $1.20 output. It also fixed the cache hit rate at 95%. Costs average every attempt, including failures. If your harness gets a lower cache hit rate, input tokens make up more of the bill, and cutting output tokens saves less in percentage terms.

Where the savings come from

The training approach is simple. Particle trained a rank-64 LoRA adapter on the experts in every layer, about 1.25% of the model’s parameter count. It used GSPO with a reward that pays for solving tasks with fewer reasoning and tool-call tokens. Training ran in two stages: coding first, then mostly data engineering.

Particle’s trajectory analysis says roughly 90% of the savings on Terminal-Bench, ReactBench and ADE come from reasoning tokens. On DeepSWE, tool-call text accounts for about 30%. The patterns it describes will look familiar to anyone who has watched an agent run:

• It stops when the task is done. In one calendar task, about 94% of the savings came after the correct file was already written. The completion and confirmation text shrank from 5,193 to 1,078 tokens.
• It goes through fewer trial-and-repair loops. On a ReactBench task, the base model spent turns repairing failed patch applications (heredocs, working directories, string matching). Particle-1 got to a working patch in 29 calls instead of 43.
• It starts editing sooner. On go-git merge conflicts, Particle-1 began implementing on call 29 versus call 43.

Particle also flags one case where the savings aren’t like-for-like. On an ADE Bench primary-key task, Particle-1 reused an existing surrogate-key macro, while the base model built an incrementing key. Particle notes that the two solutions had different semantics. When you evaluate this model, don’t stop at whether the run passed. Check whether the shorter run delivered the same thing.

The post also shows how far you can push the adapter. On one Harvey LAB contract-review task with eight rollouts, the standard adapter used 24.6% fewer tokens, and all eight reports passed. At 8x adapter strength, output fell 78.7%, but only three of eight reports passed the strict check. Compress too far and the model cuts useful qualifications along with the waste. This is a single task, so treat it as a hint, not a result.

Wiring it into a harness

The Particle docs describe an OpenAI-compatible endpoint at https://api.particle.ai/v1 with a 1,048,576-token context. It also serves DeepSeek V4.1 Flash (deepseek-ai/deepseek-v41-flash-1017) and GLM 5.3 Flash, so you can A/B the post-train against its base on the same endpoint. Vercel announced Particle-1 on AI Gateway as particle/particle-1. If you already route through the gateway, its virtual models let you swap it in centrally.

The gateway defaults differ from the benchmark settings, and that matters if you want to reproduce Particle’s numbers. If you send no tail-sampling control, the gateway applies top_p 0.85. If you omit both max-token fields, it caps output at 32,000 tokens. Requests default to high reasoning effort. Set these explicitly:

from openai import OpenAI

client = OpenAI(base_url="https://api.particle.ai/v1", api_key="pai-...")

resp = client.chat.completions.create(
    model="particle-1",
    messages=messages,
    temperature=1,
    top_p=0.95,              # benchmark setting; gateway default is 0.85
    max_completion_tokens=128000,  # gateway default cap is 32000
    extra_body={"prompt_cache_key": session_id},
)
u = resp.usage
print(u.completion_tokens, u.completion_tokens_details.reasoning_tokens)

prompt_cache_key keeps a conversation’s repeated prefix on the same server. Particle’s cost math assumes a 95% cache hit rate, so this setting carries a lot of weight. The docs also say a 429 means the priority queue timed out after up to 30 seconds and that retrying after Retry-After is safe. Make sure your agent loop backs off instead of failing the task.

How to evaluate it

We’ve previously covered how Cursor put DeepSeek V4.1 Flash on its cost frontier, and how off-peak pricing and cache hits change its economics. Particle-1 adds a different lever: the same base model with less deliberation. A fair internal test:

1. Pick 20 to 30 real tasks from your backlog. Run each one several times on both particle-1 and the base DeepSeek ID through the same endpoint and harness.
2. Log output tokens, reasoning tokens, cache hit rate and pass/fail per attempt, with failures included in the cost.
3. Review the diffs for the shortest passing runs. Particle’s own ADE example shows that fewer tokens can mean a different solution.
4. Compare cost per accepted change, not cost per run, as in our effort-level cost analysis.

The launch post describes access through the Particle API and does not announce downloadable weights. Particle says this first release targets software engineering and that it plans other domains. If its numbers hold on your tasks, a 28% pooled cut in output tokens per task (28.4% to 52.2% depending on the benchmark) at the same token price is worth a lane in your router. Coverage of the launch, such as RuntimeWire’s, describes the bet the same way: efficiency from post-training at base-model token rates.

Load X post

Loading this post connects to X.

The original source is available above.