Quick takeaways
- DeepSeek-R1 is a reasoning model: it emits a long chain of thought before the final answer.
- Best for math, coding, competitive programming, research, and complex problem solving.
- API pricing is typically far below OpenAI o-series rates, but output tokens include the reasoning trace.
- Open weights and distilled variants make local and self-hosted setups practical.
- Always review reasoning outputs; confident chains of thought can still contain errors.
How to think about AI model choice
Andrej Karpathy explains what large language models are good at and how to pick the right model for a task.
What is DeepSeek-R1 and why it matters
DeepSeek-R1 is a large language model trained to reason explicitly. Instead of jumping straight to an answer, it generates an internal chain of thought: it restates assumptions, tries intermediate steps, checks itself, and then produces a final response. That behavior makes it especially useful for tasks where the path matters as much as the result.
It matters because it is openly available. You can use it through DeepSeek's chat app, through the DeepSeek API, or by downloading the weights and running them yourself. For teams that want transparency, cost control, or air-gapped inference, the open-weights path is a real alternative to closed reasoning models like OpenAI's o-series.
R1 also popularized the idea that reinforcement learning and reasoning-focused training can push open models close to the best closed reasoning systems on math and coding benchmarks. That does not mean it is always correct, but it does make it a practical default for reasoning-heavy workflows.
Best use cases
- Mathematics. Algebra, calculus, probability, and step-by-step derivations where you need the logic exposed.
- Coding. Debugging, refactoring, algorithm design, and explaining complex code paths.
- Competitive programming. Generating and iterating on solutions under constraints, though you still need to verify edge cases.
- Research analysis. Breaking down papers, comparing methods, and structuring arguments.
- General reasoning tasks. Tradeoff analysis, logic puzzles, planning, and any prompt where you want the model to think out loud.
API pricing
DeepSeek-R1 is usually priced well below premium closed reasoning APIs. Prices change, so treat these numbers as approximate anchors and confirm the current rate on DeepSeek's official pricing page before running large workloads.
| Model | Input / 1M tokens | Output / 1M tokens | Context window |
|---|---|---|---|
| DeepSeek-R1 | ~$0.55 | ~$2.20 | ~64K |
| DeepSeek-V3 | ~$0.07 | ~$0.30 | ~64K |
| OpenAI o1 / o3-mini (approx.) | ~$2.50–$15.00 | ~$10.00–$60.00 | ~64K–200K |
Why output tokens matter. R1 charges for the full reasoning trace plus the final answer. A single request can easily emit thousands of output tokens, so the effective cost per user-facing answer can be higher than the headline output rate suggests. Cache repeated context, cap maximum tokens, and stream responses when latency matters.
Local and self-hosted setup
DeepSeek released open weights for R1 and smaller distilled versions trained from Llama and Qwen backbones. That makes local setup possible across a wide range of hardware.
- Ollama. The fastest way to experiment on a laptop or workstation. Use a command like
ollama run deepseek-r1and pick a distilled size that fits your RAM or VRAM. - llama.cpp. Best for CPU inference, edge devices, and highly quantized GGUF models. Useful when you do not have a large GPU.
- vLLM. Best for a local or on-prem OpenAI-compatible API with high throughput. Works best on NVIDIA GPUs and Linux.
Hardware guidance.
- Distilled 1.5B–7B: runs on most modern laptops with 16 GB RAM or an 8 GB GPU.
- Distilled 14B–32B: needs 24–48 GB VRAM or a machine with 64 GB+ system RAM for CPU offload.
- Full R1 (~671B): requires multiple high-memory GPUs or a dedicated inference cluster. Not a single-workstation model.
The distilled models trade some reasoning depth for size, but they are surprisingly capable for coding and math. Start with the largest quantized variant that fits comfortably on your hardware.
Limitations and safety considerations
- Censorship and refusals. R1 can refuse or hedge on certain topics more often than general chat models. If your use case touches policy-sensitive areas, test refusal behavior before relying on it.
- Reasoning length. The chain of thought is verbose. It helps transparency but inflates latency, output tokens, and cost. You may want to strip or summarize the trace for end users.
- Context window. Around 64K tokens. That is enough for most prompts but smaller than some long-context competitors. Long documents may need chunking.
- Hallucinations in reasoning. A long, confident chain of thought is not proof of correctness. Verify math, code, and factual claims.
- Safety review needs. Treat generated code and analysis as draft material. Run tests, review outputs, and avoid exposing raw reasoning traces to end users without filtering.
R1 vs V3 vs other reasoning models
Without AI vs. with AI
| Task | Without AI | With AI |
|---|---|---|
| Hard reasoning | Students and analysts work through problems manually or with calculators. | DeepSeek-R1 generates explicit reasoning chains for math, logic, and science. |
| Debugging code | Developers trace bugs by reading logs and adding print statements. | R1 reasons through error traces and suggests targeted fixes. |
| Proofreading logic | Teams review long reports for inconsistencies by hand. | R1 flags logical gaps and asks clarifying questions. |
| Competitive programming | Coders practice with static problem sets and static hints. | R1 explains approach, writes code, and iterates on test failures. |
| Cost of reasoning | Frontier reasoning APIs are expensive for large workloads. | DeepSeek-R1 API is priced low enough to experiment with reasoning at scale. |
FAQ
What makes DeepSeek-R1 different from DeepSeek-V3?
R1 is trained to reason explicitly and shows a chain of thought before answering. V3 is a general-purpose model that is faster, cheaper, and better suited to everyday chat and writing tasks.
How much does the DeepSeek-R1 API cost?
Approximate rates are around $0.55 per million input tokens and $2.20 per million output tokens. Because output includes the reasoning trace, long responses can add up quickly. Verify current pricing on DeepSeek's site.
Can I run DeepSeek-R1 locally?
Yes. The full model is very large, but distilled versions are easy to run through Ollama, LM Studio, llama.cpp, or vLLM on consumer or server hardware.
Is DeepSeek-R1 good for coding?
Yes. It performs strongly on coding benchmarks and is useful for debugging, algorithm design, and code explanation. Always review and test generated code before using it.
What are the main limitations of DeepSeek-R1?
Verbose reasoning traces, occasional refusals on sensitive topics, a 64K context window, and the risk of plausible-looking but incorrect reasoning. Plan for output filtering and human review.
Why does R1 show its reasoning?
The chain-of-thought helps users audit logic and catch mistakes, though it can be verbose.
How long are R1's reasoning traces?
They vary by question complexity; long traces can increase token usage and cost.
Is R1 good for everyday writing?
V3 is usually better for chat and writing; R1 is optimized for reasoning tasks.
What are distilled R1 models?
Smaller models trained on R1 outputs that run faster on consumer hardware.
Can R1 be used commercially?
Check DeepSeek's current license. Open-weight releases typically allow commercial use within their terms.