Particle-1 vs DeepSeek: $0.36 vs $0.34 a Task

A San Francisco startup called Particle launched on 28 October 2026 with one model, Particle-1. It's DeepSeek V4.1 Flash with a LoRA adapter trained by reinforcement learning to finish coding tasks in fewer tokens. The launch post says it uses about 45% fewer tokens on average and costs 34.4% to 51.6% less per task than the base model, with pass rates inside the base model's confidence interval.

The token savings look real. The cost figure needs a second look. The chart prices both models at DeepSeek's own peak rates ($0.30 input, $0.006 cached, $1.20 output per million tokens), but the model is only sold on its maker's API, which charges $0.25, $0.03 and $1.00. The cached rate there is 5x DeepSeek's. Agent sessions are mostly cached input, so on the longest benchmark the 34.4% saving turns into a 5.7% premium over calling DeepSeek directly.

Below is that task costed line by line from the two official price tables, the cache hit rate where the answer flips, the off-peak windows in Indian time, and an OpenCode config you can copy.

Table of contents

• What Particle shipped
• The price the launch chart assumes
• One DeepSWE task costed both ways
• Where Particle-1 wins
• Off-peak windows in IST
• Setup in OpenCode
• FAQ
• Sources

What Particle shipped

The company tested it on four agent benchmarks, all run through the Terminus 2 agent at max reasoning: DeepSWE 1.1, Terminal-Bench 2.1, ReactBench and ADE Bench. Across them the fine-tune used 28.4% to 52.2% fewer output tokens. The company says reasoning accounts for about 90% of the savings on three of the four. On DeepSWE 1.1, tool-call text adds about 30%.

General scores barely moved: GPQA Diamond 90.40% (base 90.91%), Tau Airlines 86.00% (base 88.00%), MMLU 86.08% (base 85.98%).

The price the launch chart assumes

The headline chart is DeepSWE 1.1, the longest of the four benchmarks:

The footnote under it explains the cost row. Both models were billed at the same rates, $0.30 / $0.006 / $1.20, with a fixed 95% cache hit rate (a blended input rate of $0.0207 per million).

Those are DeepSeek's peak prices for deepseek-flash on DeepSeek's own API. Nobody can buy the fine-tune at them. Particle's pricing page lists it at $0.25 / $0.03 / $1.00, with the same rates for the copy of DeepSeek V4.1 Flash that Particle also hosts. Input and output are a little cheaper than DeepSeek's peak. Cached input costs 5x as much.

So the chart answers "how much would the fine-tune save if DeepSeek served it?" It doesn't answer the question a buyer has, which is whether Particle-1 on Particle beats DeepSeek on DeepSeek.

One DeepSWE task costed both ways

The launch post publishes output tokens and cost but not input tokens. Both are enough to work input out. Take away output at $1.20 and divide what's left by the $0.0207 blended input rate. That gives about 7.23M input tokens per task for the fine-tune and 11.44M for DeepSeek. Fewer, shorter turns mean less history to resend, so it saves input as well as output. These are averages over all attempts, failures included, derived from the launch post's own numbers.

Keep the 95% hit rate and apply each provider's real peak price:

The fine-tune does less work and still costs 5.7% more. Cached input is 57.9% of its bill, and that's the one line priced at 5x. Over 1,000 tasks a month that's $355.90 against $336.80.

The off-peak column doesn't rescue it. Both providers halve every rate off-peak, so the fine-tune at its off-peak price ($0.1779) still sits 5.7% above DeepSeek at DeepSeek's off-peak price ($0.1684).

Where Particle-1 wins

The gap depends on how much of each prompt hits the cache. Uncached input is the line where the newcomer is cheaper per token, and it sends fewer tokens. As the hit rate falls, it pulls ahead:

The lines cross at a 93.9% hit rate. Below that the fine-tune is cheaper, above it DeepSeek direct is. Long Claude Code or OpenCode sessions with a big fixed system prompt and tool list sit above 95% most of the time. Short one-shot jobs, frequent context resets and parallel sub-agents that each start cold sit lower.

Three more cases favour it:

• You already use Particle's hosted DeepSeek. At those rates the base model costs $0.5525 on this task, so switching to the fine-tune saves 35.6%. That's close to the launch claim, because the comparison is now like for like.
• You run during Particle's off-peak window and DeepSeek's peak. The fine-tune off-peak costs $0.1779 against DeepSeek's peak $0.3368, 47.2% less. The next section shows when that overlap happens in India.
• You can use Flex. Paying accounts can send service_tier: "flex" for 50% off every token rate, stacked on the time-of-day price. Off-peak on Flex it comes to $0.0890 a task, 47.2% below DeepSeek off-peak. Flex requests wait behind standard traffic, and a request queued for more than 30 seconds fails with 429 fleet_capacity_exhausted without being charged.

Speed is a separate gain. The fine-tune took 28.4% fewer output tokens on DeepSWE, and output is what you wait for. The Terminal-Bench example in the launch post cut one git-deployment run from 47,006 output tokens to 15,892.

To price your own mix, enter your token counts in the API Cost Calculator. Particle-1 is now listed at its peak rates, next to DeepSeek V4.1 Flash at DeepSeek's off-peak rate.

Off-peak windows in IST

The two providers split the day differently.

The newcomer's off-peak runs 20:30 to 04:00 New York time and follows US daylight saving. That's 06:00 to 13:30 IST today. US clocks go back on 1 November 2026, and from then the window is 07:00 to 14:30 IST. The other 16.5 hours are peak.

DeepSeek's peak is only 01:00 to 04:00 and 06:00 to 10:00 UTC on weekdays, which is 06:30 to 09:30 and 11:30 to 15:30 IST. Everything else is off-peak, weekends and Chinese public holidays included. That's 133 of the 168 hours in a week.

For a developer in India, a weekday morning (07:00 to 09:30 and 11:30 to 14:30 IST, from 1 November) is the one slot where the newcomer is off-peak while DeepSeek is at peak. That's where the 47.2% saving above applies. In the evening, DeepSeek is off-peak and the newcomer is at peak, the worst pairing for it. The DeepSeek Flash in Claude Code post covers DeepSeek's peak hours in more detail.

Setup in OpenCode

OpenCode is a documented, supported client. This is the config from its quickstart, with the key read from an environment variable:

{
  "$schema": "https://opencode.ai/config.json",
  "model": "particle/particle-1",
  "provider": {
    "particle": {
      "name": "Particle",
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "https://api.particle.ai/v1",
        "apiKey": "{env:PARTICLE_API_KEY}",
        "includeUsage": true,
        "setCacheKey": true,
        "supportsStructuredOutputs": false
      },
      "models": {
        "particle-1": {
          "id": "particle-1",
          "name": "Particle-1",
          "reasoning": true,
          "tool_call": true,
          "limit": { "context": 1048576, "output": 32000 },
          "options": { "reasoningEffort": "high" }
        }
      }
    }
  }
}

Export the key first with export PARTICLE_API_KEY=YOUR_API_KEY. Keys start with pai- and are shown once, at creation.

setCacheKey is the line that controls your bill. The gateway routes requests with the same prompt_cache_key toward the same server, and that's how hits stay high. The docs call it an affinity hint, not a guarantee. A restart or a rebalance can send a turn to a cold server. With any other OpenAI-compatible client, send one key per conversation:

{
  "model": "particle-1",
  "prompt_cache_key": "conv-YOUR_SESSION_ID",
  "messages": []
}

Then read usage.prompt_tokens_details.cached_tokens on each response to see your real hit rate. Put the system prompt, tool schemas and files first and the new turn last, or the prefix changes and nothing caches.

Two other settings to check:

• The launch benchmarks ran at max reasoning. The API default is high, so your token counts can differ from the launch chart.
• Structured outputs aren't guaranteed. json_object is accepted, but a json_schema you send is passed through without constrained decoding. Validate tool output yourself, for example with the JSON Formatter while you're debugging.

FAQ

Are Particle-1's weights open? Not yet. The launch post and docs point only to the hosted API, so for now you can't run it on your own GPU.

Does Particle store my prompts? The data retention page says the company keeps keys, usage records and files you upload, but not prompts. The site lists zero data retention as a feature.

Is web search cheaper than DeepSeek's? No. Hosted search on this API costs $2.50 per 1,000 searches. DeepSeek's Search and Fetch APIs cost $0.75 per 1,000 requests each. DeepSeek starts billing the calls its harness, Claude Code and Codex make for those tools at 00:00 Beijing time on 1 November 2026.

Is Particle-1 better at coding than the base model? Not measurably. Pass rates sit within the base model's confidence interval on all four benchmarks. On DeepSWE 1.1 it scored 72.57% against 71.15%. You're paying for fewer tokens, not more accuracy.

Sources

• Introducing Particle-1, Particle, 28 October 2026 (benchmark table, cost footnote, training details)
• Particle pricing, read 31 October 2026
• Usage and billing, Particle docs (peak and off-peak windows, Flex, web search)
• Model catalog, Prompt caching, Reasoning controls, Service tiers and Quickstart, Particle docs
• Models and pricing, DeepSeek API docs, read 31 October 2026