Particle-1 is Particle AI’s post-trained coding model derived from DeepSeek V4.1 Flash. Its distinct proposition is task efficiency: reduce unnecessary reasoning and tool activity while still completing software work. It is not an official DeepSeek release, and a familiar OpenAI-compatible client does not turn it into an OpenAI model.
The maker’s October 28 launch post provides a technical account of the training and evaluation, not just a gateway listing. That supports a standalone integration guide. We have not independently reproduced its benchmarks or tested it on a customer repository.
What is actually different?
The launch focuses on software engineering and data-engineering tasks. Particle describes reinforcement learning aimed at reducing redundant deliberation, repeated repair and unnecessary exploration. Those are vendor explanations of the observed behavior, not proof that shorter output always means better work.
That distinction creates a useful evaluation question. Does the model remove wasted activity, or skip checks your team needs? Both can reduce token totals. A successful benchmark case does not by itself establish whether a production patch contains adequate tests, documentation and error handling.
Keep Particle-1 separate from its base model in routing, logs and evaluation records. Choosing a post-trained derivative changes the model being evaluated, even when the architecture or familiar tool format encourages treating it as interchangeable. Our AI application architecture guide covers how to isolate those provider decisions.
API identities and limits
The official Particle catalog distinguishes request alias particle-1 from the public identity particle-ai/particle-1. It documents a 1,048,576-token combined context and an output ceiling of 131,072 tokens. The default output cap is 32,000 when the caller supplies no explicit limit.
Text and image input lead to text output. Tool calling is qualified; do not infer every SDK feature from the compatibility label. In particular, the direct catalog does not advertise a schema-guaranteed structured-output path. JSON output acceptance is different from a guarantee that an arbitrary schema is enforced.
For a typed application, keep your own validation and reject invalid responses before applying side effects. See Zod response validation and the JSON parsing foundation. A model producing valid JSON still may invent an identifier or choose the wrong operation.
Current pricing versus launch benchmark assumptions
Prices below are US dollars per million tokens, checked October 29. They describe the named route, not a universal future price or an all-in agent task cost.
| Access surface | Model selection | Input | Cached input | Output |
|---|---|---|---|---|
| Particle direct catalog | particle-1 request alias | $0.25 | $0.03 | $1.00 |
| OpenRouter listing | particle-ai/particle-1 | $0.25 | $0.03 | $1.00 |
Sources: Particle’s current catalog and OpenRouter’s route. Matching numbers do not make the accounts, data policies or supported parameters interchangeable.
The launch post’s benchmark footnote uses $0.30 input, $0.006 cached input and $1.20 output for its Particle-1 and DeepSeek comparison. Those are the evaluation’s accounting assumptions, not the current catalog row above. Do not silently substitute today’s rates into the published per-task benchmark and call it the same experiment.
Compare providers through our API pricing guide, but retain the provider route in every cost record. A gateway price is not evidence of a direct account’s terms, and an advertised low unit price does not include every retry or external tool charge.
A minimal direct connection
Particle’s API introduction documents an OpenAI-compatible base URL at https://api.particle.ai/v1. A minimal Python example is:
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["PARTICLE_API_KEY"],
base_url="https://api.particle.ai/v1",
)
response = client.chat.completions.create(
model="particle-1",
messages=[{"role": "user", "content": "Review this proposed migration."}],
max_tokens=1200,
)
print(response.choices[0].message.content)This is a documentation-based example, not a paid request executed for the guide. The environment-variable name is an application convention in this snippet. Use a Particle-issued credential; an OpenAI credential is not interchangeable.
Start with text and a bounded response before adding tools or streaming. Keep the chosen model ID explicit. Log returned model identity and usage so an alias or provider change does not disappear inside a generic “OpenAI-compatible” adapter. Our API authentication comparison explains the surrounding credential boundaries.
Reading the vendor benchmarks correctly
Particle reports evaluation across Terminal-Bench 2.1, ReactBench, ADE Bench and DeepSWE 1.1. Its launch describes output-token reductions from 28.4% to 52.2% against the base model in those evaluations, with pass rates within the reported confidence intervals. Those results belong to the maker’s specified harness and conditions.
We do not convert them into a portfolio ranking or claim a guaranteed savings percentage. The useful signal is that the maker publishes trajectories and discusses what changed, including cases where solution semantics differ. That gives a team hypotheses to test rather than a substitute for its own acceptance criteria.
For an evaluation, count all attempts and compare accepted changes, not only successful examples. Preserve the same task fixture, source revision and tool permissions. Record how much extra review the shorter trajectory needs. Use testing generated code as the acceptance layer.
Coding-agent fit and limitations
Start with tasks where unnecessary exploration is expensive but completion is objectively testable: a bounded bug fix, a small migration or a data transformation with a known expected result. Avoid starting with an unrestricted production deployment or a task judged only by how confident the final message sounds.
Measure missing checks explicitly. Does the patch handle rollback? Did it inspect a failing test rather than delete it? Did it preserve user changes? A model that stops earlier can be useful, but only if “done” matches your team’s definition. Our LLM regression-testing guide helps keep that definition stable across model changes.
We have not verified a downloadable Particle-1 weight release or a local inference contract from these sources. Do not assume that its open-weight base makes the derivative itself downloadable. Likewise, the OpenRouter route currently does not advertise EU in-region routing. Review the actual route’s data handling instead of inferring residency from a provider’s headquarters.
My take
Particle-1 is worth a focused coding-agent evaluation because its documented objective is reducing wasted work, not merely posting another general leaderboard score. The strongest adoption case would be lower cost per accepted patch with the same required checks. Until you measure that, treat efficiency as a vendor hypothesis and keep the base model as a meaningful control.
FAQ
Is Particle-1 an official DeepSeek model?
No. Particle AI describes it as a post-trained derivative of DeepSeek V4.1 Flash. Keep the publisher and model identity distinct.
Which model name should I send?
Particle’s direct guides use particle-1; its public model identity and OpenRouter route use particle-ai/particle-1. Follow the selected provider’s contract.
Does it guarantee structured JSON schemas?
The direct catalog does not advertise that guarantee. Validate application output even when JSON mode or schema parameters are accepted.
Is the advertised token reduction independently verified here?
No. The cited results are vendor-reported. We have not reproduced the experiments or measured a customer workload.
Can I run it locally?
The sources reviewed establish hosted API access, not a downloadable derivative. Do not confuse the base model’s availability with Particle-1’s release terms.