Setting up DeepSeek V3.2 on your hardware, agent stack live, production-grade in 14 days

DeepSeek V3.2 is the open-weight model that beat GPT-5 on the hardest reasoning benchmarks. Released December 1, 2025 under MIT license, it pairs a 671 billion total / 37 billion active MoE architecture with DeepSeek Sparse Attention, a fine-grained sparse pattern layered on Multi-head Latent Attention that cuts long-context inference cost while leaving output quality nearly unchanged.

  • 14-day production cutover
  • Coding + research agent stack included
  • 671B total, 37B active per token (MoE) Parameters
  • 128K tokens Context window
  • 14 d Production cutover

DeepSeek V3.2 at a glance

Specs that matter when picking the model and the hardware.

Parameters

671B total, 37B active per token

Architecture

MoE, 256 routed + 1 shared expert, DeepSeek Sparse Attention

Context window

128K tokens (max output 64K)

License

MIT

Release

December 1, 2025 (V3.2-Exp in September 2025)

Variants

V3.2 (general), V3.2-Speciale (deep reasoning, no tool calling)

Min VRAM (Q4)

376GB total, multi-GPU mandatory

Min VRAM (FP8)

~675GB, 8x H200 node

Tokens/sec on Mac Studio M3 Ultra 512GB Q4

8-15 (single user)

Tokens/sec on 8x H100 FP8 vLLM

200-400 batched

Hardware that runs DeepSeek V3.2 in production

Three tiers, real SKUs, real throughput numbers.

  1. Entry tier: Mac Studio M3 Ultra 512GB ($14,999) at Q4

    Throughput: 8-15 tokens/sec. Best for: Single power user, research, occasional hard reasoning, not production serving.

  2. Mid tier: 4x RTX Pro 6000 Blackwell 96GB ($40-56K) at Q4 or 2x AMD MI300X 192GB

    Throughput: 30-60 tokens/sec. Best for: 5-15 user firms running hard problems, lab settings, code-heavy teams.

  3. Enterprise tier: 8x H100 80GB ($200K), 4x H200 141GB ($150-200K), or 8x B200 FP4 ($300K+)

    Throughput: 200-500 tokens/sec. Best for: Production serving, agentic workflows, 50+ concurrent reasoning users.

Quantization picks for this model

GGUF, AWQ, FP8, INT4.

Recommended quantization

FP8 native on Hopper and Blackwell for production. Q4_K_M for Mac single-user. Q2_K only if you must fit 192GB and accept a 5 to 8 percent quality dip on reasoning.

Tradeoffs

Reasoning models suffer more from aggressive quantization than chat models because chain-of-thought amplifies precision errors. Q4 holds up well on knowledge and edit-style code. Q2_K shows real wobble on math and structured reasoning. 1.58-bit demos exist (2x RTX 4090 plus RAM) but are not production-grade.

GGUF Q2_K

File size: 210GB.

GGUF Q4_K_M

File size: 376GB.

FP8

File size: ~675GB.

FP16

File size: 1.34TB.

Coding agents we wire to DeepSeek V3.2

DeepSeek Sparse Attention (DSA) gives near-linear scaling for long context, which is decisive on agentic loops where context grows with every tool call.

Claude Code (with custom endpoint)

DeepSeek's official integration target. SWE-bench Verified 72 to 74 percent on Claude Code framework. Override OPENAI_BASE_URL to your vLLM. DeepSeek V3.2 is the open model that comes closest to Claude Sonnet on Claude Code's harness. Pineido's pick when the buyer wants Claude-Code-quality output without the API spend.

Roo Code

Officially benchmarked. The DeepSeek paper notes Roo Code simulates tool interactions via user messages, and DeepSeek V3.2's context-management strategy handles this correctly. SWE-bench Verified 72 to 74 percent on Roo Code framework. Multi-mode (Code, Architect, Ask) all functional.

Cline

OpenAI Compatible provider, vLLM endpoint. Watch the active vLLM bug where DeepSeek tool-call tags can leak into reasoning content on multi-turn loops. Recent vLLM releases include the fix (commit 36056). Pin vLLM >= 0.11.2.

Aider

Strong fit. Aider's edit format aligns with DeepSeek's instruction-following. Use --model openai/deepseek-v3.2 against your vLLM endpoint. The 128K context limit is the constraint, not the editing accuracy.

OpenHands

Container-based agent. DeepSeek V3.2 with Terminus in non-thinking mode hit 39.3 on Terminal Bench 2.0 per the paper. SWE-bench Verified 72 to 74 percent translates to strong autonomous-loop performance. Pineido's pick for repo-scale tasks when budget rules out frontier APIs.

Continue.dev

config.yaml with provider: openai, apiBase to vLLM /v1, capabilities: [tool_use]. Agent mode auto-detects native tool calling. DeepSeek V3.2's reasoning parser separates thinking from response, so Continue's chat panel renders cleanly.

OpenCode / OpenClaw

Officially supported per DeepSeek's own coding-agent integration guide. Drop-in OpenAI endpoint config. The Hermes Agent and Codex frameworks are also listed in DeepSeek docs.

Coding agent use cases

Where this model + agent stack ships real work.

What clients said after launch

Feedback from the people who were in the room when decisions were made.

I used to spend every Sunday reconciling contractor invoices. Now they match automatically. I got my weekends back.
Karen, Property ManagerDenver
We stopped debating architecture in circles and shipped a working release that leadership could evaluate live.
Declan, Head of OperationsLondon
They did not ask us to trust a rewrite plan. They proved one critical workflow first, then scaled from evidence.
Fatima, CTOSydney

Research agents we deploy on DeepSeek V3.2

Long-tail agent task generalization is DeepSeek V3.2's standout: 1,800 environments and 85K complex prompts in post-training.

GPT Researcher

Set OPENAI_BASE_URL to vLLM. DeepSeek V3.2's reasoning trace makes GPT Researcher's plan step noticeably better. Reports of 5K to 8K words with 15+ sources complete in 5 to 10 minutes.

LangGraph

Pineido default. DeepSeek V3.2's context-management strategies mesh with LangGraph's checkpoint-and-resume model. When tool history exceeds 80 percent of the 128K budget, LangGraph can swap in the Summary or Discard-75 strategy and continue cleanly.

AnythingLLM

Generic OpenAI provider. The reasoning parser separates thinking from final answer in AnythingLLM's chat UI. Great for buyer demos because the thinking trace is visible and explains the answer.

Open WebUI

Tool calling and document upload work cleanly. DeepSeek's reasoning-mode toggle exposes via Open WebUI's per-conversation settings. Watch the 128K context limit on heavy document chats.

CrewAI

Sequential research crews. DeepSeek V3.2's instruction following is strong enough that CrewAI's role and goal text drives the agents reliably. Use thinking-mode for the researcher role, non-thinking for the writer role.

AutoGen / AG2

GroupChat works but watch token cost: every agent turn replays full history through DeepSeek's 128K window. Use Discard-75 context-management strategy to keep round counts bounded.

LlamaIndex

Best retrieval pairing. Use LlamaIndex query engines for indexing, then expose them as tools inside a LangGraph or DeepSeek-native agent. The reasoning parser surfaces retrieval-decision logic in the trace.

Research agent use cases

Where this model + research agent stack delivers reports your team actually uses.

Frameworks we ship for production agent workflows

Pick the framework by workflow shape.

LangGraph

Production orchestration. Best fit for DeepSeek's context-management strategies.

CrewAI

Sequential crews. Fast to demo with DeepSeek's strong instruction following.

AutoGen / AG2

GroupChat. Watch context budget on multi-agent debates with DeepSeek's 128K cap.

DSPy

Prompt compilation. Pairs well with DeepSeek's reasoning trace for chain-of-thought optimization.

Pydantic AI

Type-safe agents. DeepSeek's structured output reliability fits clean schemas.

LlamaIndex

Retrieval layer. Hybrid stack with LangGraph orchestration on top.

Who picks DeepSeek V3.2

Three buyer profiles where this model is the right answer.

  1. Quant trading firm, 25 researchers

    Task: Strategy code, derivative pricing, complex math validation. Outcome: IMO/IOI gold-medal class reasoning runs in-house. MIT license clears the legal review with no caveats. 8x H100 ROI inside 6 months versus paid frontier API.

  2. Patent law firm, 18 attorneys, IP-heavy

    Task: Prior art analysis, claim drafting, technical specification review across 10+ technical domains. Outcome: Frontier reasoning quality on hard technical claims, full 128K context for multi-patent comparison. MIT license means no attribution friction in client deliverables.

  3. Biotech R&D, 30 scientists

    Task: Molecular reasoning, protocol generation, deep literature synthesis. Outcome: Speciale variant delivers theorem-proving and deep-reasoning on par with closed labs. Hardware investment justified by frontier quality without API data exposure.

DeepSeek V3.2 vs the closest rivals

Where this model wins, where it loses.

vs Qwen3 235B A22B

DeepSeek V3.2 wins on hardest math, code, and IMO-class reasoning. Qwen3 235B wins on hardware floor (143GB versus 376GB at Q4) and on hybrid thinking-mode flexibility. Below 4x H100 budget, Qwen3 235B is the rational pick.

vs GPT-5 (closed)

DeepSeek V3.2 performs comparably to GPT-5 on commodity tasks. V3.2-Speciale exceeds GPT-5 on theorem proving and IMO, scoring 96.0 on AIME 2025 versus GPT-5-High at 94.6. The catch is verbosity: Speciale spends far more output tokens to reach those scores. The win for V3.2: data stays on your hardware. The cost: enterprise-grade GPU capex.

vs Mistral Large 3 (675B MoE)

Both are 670B-class MoE on 128GB+ hardware. Mistral Large 3 wins on multimodal vision. DeepSeek V3.2 wins on reasoning and code. Mistral Large 3 has a slightly better small-firm story via 14B/8B/3B siblings.

How Pineido sets up agents on DeepSeek V3.2

Day 4 vLLM serves V3.2 with the v32 tool-call parser plus reasoning parser.

Day 4

vLLM serves DeepSeek V3.2 with --tensor-parallel-size 8 (or TP=2 with DP/EP for Hopper to avoid head-padding penalty), --tokenizer-mode deepseek_v32, --tool-call-parser deepseek_v32, --enable-auto-tool-choice, --reasoning-parser deepseek_v3, --max-model-len 131072. Pin vLLM >= 0.11.2 for the multi-turn tool-call fix.

Day 6

Claude Code via OPENAI_BASE_URL override, Roo Code as OpenAI Compatible, Cline same, Aider via --openai-api-base. SWE-bench-class scaffolds work out of the box because DeepSeek's training pipeline included these frameworks.

Day 8

Open WebUI plus AnythingLLM live. Reasoning toggle exposed per conversation. Workspaces isolate sensitive document sets.

Day 10

LangGraph workflows with context-management strategies (Summary, Discard-75) wired into checkpoint logic. Three workflows shipped: deep-research, repo-review, customer-triage.

Day 12

OpenHands repo-autonomy. Expected SWE-bench Verified pass around 70 to 73 percent on routine tasks given the model's 72 to 74 percent benchmark range.

Day 14

Evidence pack with tool-call success rates, throughput, reasoning-trace samples, runbook, and agent inventory delivered.

How we deploy DeepSeek V3.2 in 14 days

Fixed fee.

Day 1

Hardware audit. Confirm GPU node or 512GB Mac. Run real reasoning prompts on V3.2 versus V3.2-Speciale. Pick variant by workload.

Day 4

Serve via vLLM with FP8 on Hopper or Blackwell. Configure DeepSeek Sparse Attention for long-context cost savings. OpenAI-compatible API in front.

Day 9

RAG with high-quality reranker (BGE reranker v2-m3). Tool-calling pipeline (V3.2 base only, Speciale does not support tools). RBAC, audit, cost telemetry per expert.

Day 14

Pen-test cleared. MIT license NOTICE filed (one line). Production cutover with FP8 throughput baseline.

Common questions, plain answers

Is DeepSeek V3.2 actually MIT licensed?

Yes. Both repository and model weights are MIT. No MAU cap, no commercial restriction, no attribution string in product. Counsel-friendly license that ships clean through any procurement review. You can redistribute, fine-tune, and embed in commercial products without contacting DeepSeek.

Can I run DeepSeek V3.2 on a Mac Studio?

Mac Studio M3 Ultra 512GB at Q4 is the cheapest single-machine path. Around 8 to 15 tokens per second for one user. Fine for research, slow for production serving. Below 192GB unified memory you are forced into Q2 or 1.58-bit and the reasoning quality wobble shows up on hard tasks.

Should we deploy V3.2 base or V3.2-Speciale?

Base V3.2 supports tool calling and is the daily driver for agents, RAG, and general work. Speciale is the high-compute deep-reasoning variant, gold-medal class on IMO and IOI, but does NOT support tool calling. Run base for production. Add Speciale as a specialist endpoint for the hard reasoning queue if you have the GPU budget.

How low can we quantize without losing quality?

FP8 is near-lossless on H100 and H200. Q4_K_M loses 2 to 4 percent on commodity tasks. Q2_K shows 5 to 8 percent dips on math and structured reasoning. For a reasoning model, do not go below Q4 in production. Reasoning chains amplify quantization errors more than single-shot answers.

Is DeepSeek V3.2 a real Claude Sonnet alternative for coding agents?

On agentic coding benchmarks DeepSeek V3.2 sits in the low-to-mid 70s on SWE-bench Verified (72-74 percent), a few points behind GPT-5.1-High and Gemini 3 Pro and roughly 7 to 9 points behind the leader, Claude Opus 4.5 at about 81 percent. On routine refactor work the gap is rarely visible. The decisive factor is licensing: DeepSeek V3.2 is MIT, runs on your hardware, no third-party processor, no per-token API spend. For HIPAA, GDPR, defense, or strict-NDA buyers, that benchmark gap is worth it. For frontier-quality output without the constraints, hybrid-route the hardest 10 percent of tasks to Claude via a private BAA endpoint.

What vLLM flags does DeepSeek V3.2 need?

--tokenizer-mode deepseek_v32 --tool-call-parser deepseek_v32 --enable-auto-tool-choice --reasoning-parser deepseek_v3. Without all four, tool calls return empty or reasoning leaks into content. Pin vLLM >= 0.11.2 for the multi-turn streaming fix (commit 36056). On Hopper prefer TP=2 with data and expert parallelism over TP=8 because of a kernel head-padding penalty in flashmla_sparse.py.

671B total, 37B active per token (MoE) Parameters

Book the 30-minute scoping call. We tell you if DeepSeek V3.2 plus our agent stack is the right pick before you sign.

Fixed fee.

Day 1 you see the exact model, the exact hardware, the exact agent stack, the exact cost math, and the exact compliance posture.

You leave with

  1. Day 0 (this week): 30-minute scoping call. Hardware shortlist, model pick, agent stack proposal, cost projection in your inbox by Friday
  2. Day 1: Hardware audit. Confirm GPU node or 512GB Mac. Run real reasoning prompts on V3.2 versus V3.2-Speciale. Pick variant by workload.

ByFounder and Imaginator

Pineido, based in Strumica, North Macedonia, is a software company that builds websites, online shops, web and mobile apps, business automation and AI for companies at home and abroad. Work ships in 30-day sprints at a fixed price, and the client owns the code.

Published Updated