Particle AI: Particle-1 API
Particle-1 is Particle AI's first agentic coding model, built on DeepSeek V4.1 Flash and tuned to produce concise outputs using about 45 percent fewer tokens on software engineering tasks.
Particle AI: Particle-1 is an agentic coding model trained to handle software engineering work. It is post-trained on DeepSeek V4.1 Flash, which serves as its foundational architecture, and it is built to generate concise outputs suited to agentic coding workflows. It is Particle AI's first model.
The model targets automated code generation, code refactoring, and bug fixing. Its main selling point is token efficiency: it uses roughly 45 percent fewer tokens on software engineering tasks than other models, which lowers costs for teams running large volumes of coding tasks and typically means faster generation times. Particle AI positions it as a token-efficient, cost-effective alternative in the AI coding model market.
Because it is tuned for compact responses, Particle-1 fits best in agent loops and automated pipelines where every token counts. No public benchmark scores are available for the model, so evaluations should be based on your own coding workloads rather than published rankings.
Updated:
MODEL ID
particle-1- Context
- 1.049M
- Max output
- 131.072K
- Recommended API
- messages
- Input
- text / image
- Output
- text
Highlights
- Particle AI's first model
- Built on DeepSeek V4.1 Flash
- Roughly 45 percent fewer tokens
- Concise agentic coding outputs
- Cost-effective for high-volume coding
Providers
Compare API prices across providers. Select a provider to view all charges and conditions.
| $0.25 | $1 | $0.03 |
What $10 buys
- Input
- 40M tokens
- Output
- 10M tokens
Estimated from current input and output prices, before discounts.
Reasoning
- Default effort
- high
- Enabled by default
- Yes
- Always enabled
- No
- Available effort levels
- max / xhigh / high / medium / low / minimal / none
Quick Start
Drop-in code to call this model with Felo API Platform compatible APIs. Start in the Playground when you want to test prompts before writing code.
Get your API key
Create a key from your Felo API Platform account and set it as an environment variable.
export FELO_API_KEY="YOUR_API_KEY"Make your first request
Use this model ID with the Felo API Platform endpoint. Optional request headers such as X-Request-Id can help troubleshooting.
particle-1This model is reasoning-capable. If your selected protocol and model route expose reasoning controls, preserve the returned reasoning metadata when continuing a conversation.
const response = await fetch("https://openapi.felo.ai/api/v1/messages", {
method: 'POST',
headers: {
Authorization: `Bearer ${process.env.FELO_API_KEY}`,
'Content-Type': 'application/json',
},
body: JSON.stringify({
"model": "particle-1",
"max_tokens": 1024,
"messages": [
{
"role": "user",
"content": "Hello"
}
]
}),
});
if (!response.ok) throw new Error(await response.text());
console.log(await response.json());Using third-party SDKs
Use compatible SDKs by setting baseURL to https://openapi.felo.ai/api/v1. Use the Anthropic-compatible base URL for Claude-style clients. https://openapi.felo.ai/api.
Enable streaming
Add stream: true to receive responses as server-sent events.
curl -N https://openapi.felo.ai/api/v1/messages \
-H "Authorization: Bearer $FELO_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "particle-1",
"max_tokens": 1024,
"messages": [
{
"role": "user",
"content": "Hello"
}
],
"stream": true
}'Endpoint
Felo API Platform exposes compatible model-calling surfaces. Pick the surface your app or agent client already supports.
Messages
Anthropic-compatible messages for Claude-style clients.
POST
https://openapi.felo.ai/api/v1/messagesParameters
modelstringparticle-1Public model ID to call.max_tokensinteger—Maximum generated tokens.messagesarray—Conversation messages for Chat Completions.seed———stop———min_p———toolsarray—Tool calling definitions following compatible schema.top_k———top_p———logprobs———reasoning———temperaturenumber—Controls response variety when supported.tool_choicestring or object—Controls whether a tool should be called.top_logprobs———response_formatobject—Request structured output when supported.presence_penalty———reasoning_effort———frequency_penalty———include_reasoning———repetition_penalty———structured_outputs———Frequently asked questions
What is Particle AI: Particle-1?
Particle AI: Particle-1 is an agentic coding model trained to handle software engineering work. It is post-trained on DeepSeek V4.1 Flash, which serves as its foundational architecture, and it is built to generate concise outputs suited to agentic coding workflows. It is Particle AI's first model. The model targets automated code generation, code refactoring, and bug fixing. Its main selling point is token efficiency: it uses roughly 45 percent fewer tokens on software engineering tasks than other models, which lowers costs for teams running large volumes of coding tasks and typically means faster generation times. Particle AI positions it as a token-efficient, cost-effective alternative in the AI coding model market. Because it is tuned for compact responses, Particle-1 fits best in agent loops and automated pipelines where every token counts. No public benchmark scores are available for the model, so evaluations should be based on your own coding workloads rather than published rankings.
How is usage billed?
Your bill depends on the provider you use, its prices and your usage. Longer inputs or other conditions may have different prices.
What is Particle-1 designed for?
It is an agentic coding model trained for software engineering tasks, including automated code generation, refactoring, and bug fixing.
What architecture is it built on?
It is post-trained on DeepSeek V4.1 Flash, which serves as its foundational architecture.
How token-efficient is it?
It uses roughly 45 percent fewer tokens on software engineering tasks compared with other models, which lowers costs and typically means faster generation.
Are there public benchmark scores?
No. No public benchmark scores are available for the model.
Why does token efficiency matter?
Fewer tokens lower costs for teams running large volumes of coding tasks and typically shorten generation times, which suits agentic coding workflows.