DeepSeek-V3.2

DeepSeek-V3.2

A 685B open reasoning model from DeepSeek with sparse attention for long context and a chat template that lets it think while it calls tools. For teams that run large models and build agents.

Made by deepseek-ai on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: DeepSeek-V3.2 is a 685B text model from DeepSeek, built on DeepSeek-V3.2-Exp-Base. It aims to pair efficiency with strong reasoning and agent skills. The maker names three changes: a sparse attention method called DSA for long context, a scaled-up reinforcement learning stage, and a large pipeline that synthesizes training tasks for tool use. A higher-compute variant, DeepSeek-V3.2-Speciale, is also described.

Who it suits: It suits ML teams that host huge open models, and developers who build agents that must reason while they call tools.

Industry | Who uses it | How they use it | Example
Software development | Agent builders | Build assistants that call tools while they reason | The new chat template adds thinking with tools
Research | Teams that check model claims | Review the contest submissions the maker released | The card ships IOI, ICPC World Finals, IMO and CMO files for checking
Platform engineering | Teams that host open models | Serve a large model with an efficient attention method | DSA is built to cut compute on long inputs

You can skip it if you have no multi-GPU server, since the weights are about 685 GB.

Where to use it:

• Hugging Face Transformers, as the card's library
• Windows, macOS or Linux with Python, to download the files and run the encoding scripts
• A multi-GPU server that can hold the weights
• Agent code that sends OpenAI-style messages, which the encoding scripts convert for the model

Use case | Who | What they get back
Tool-using agents | Developers | A model that can reason between tool calls
Long-context work | Platform teams | Lower compute from sparse attention, as the maker states
Contest-style problems | Researchers | Submissions in a folder that others can verify

How to set it up: You need Python, a lot of storage and a runtime that supports this model.

• Python with the Hugging Face tools
• About 685 GB for the weights in F8_E4M3, or about 343 GB at 4-bit, which is an estimate
• A runtime that supports this model, since the part of the card shown here gives no serving command
• The encoding folder from the repository, for the chat template

1. Install the Hugging Face tools with Python.
2. Download the repository files with the second command below.
3. Read the encoding folder to see how messages are turned into model input.
4. Load the weights in a runtime that supports them.

pip install -U huggingface_hub
hf download deepseek-ai/DeepSeek-V3.2

How to use it: The chat template changed from earlier versions. It has a new format for tool calling and a thinking with tools feature. The repository includes an encoding folder with Python scripts and test cases. They cover turning OpenAI-style messages into input strings, and reading the replies back as messages. The card's example is cut off after its import lines:

import transformers
# encoding/encoding_dsv32.py
from encoding_dsv32 import encode_messages, parse_message_from_completion_text

Tool | What it does
encode_messages | Turns OpenAI-style messages into an input string for the model
parse_message_from_completion_text | Reads the model's text output back into a message
encoding folder | Holds the Python scripts and test cases for the template
olympiad_cases folder | Holds the contest submissions released for checking

Example: You build an agent that answers questions with a search tool. You encode the chat history with the template, so the model can think, call the tool, and think again. Then you parse its reply back into a message.

For newcomers and experts: Think of it as a huge reasoning engine that is trained to use tools as part of its thinking. A first small try is to read the encoding scripts to see how one message becomes model input.

Sparse attention lets each token look at a selected part of the context, which lowers compute on long inputs. The maker says this keeps quality while it cuts cost. It also says the high-compute variant surpasses GPT-5 and matches Gemini-3.0-Pro on reasoning. Those are the maker's claims, and the charts are images that are not readable here.

Write messages in OpenAI style
Encode them with the card's scripts
The model thinks and may call a tool
Parse the reply with the card's parser
Feed the tool result back and continue

Good to know: Weights come in two sizes in the card's record.

Title: Weight sizes
Format | Size
F8_E4M3 | About 685 GB
4-bit, estimated | About 343 GB

• Gold medal claim: the card reports gold-medal results for the high-compute variant in the IMO and IOI
• Verification: the released contest submissions are there for the community to check
• Other versions: other people have published 21 quantized and 36 fine-tuned versions
• License: MIT
• Cost to run: none named, but it needs a multi-GPU server
• Data it reaches: the files you download and the prompts you run on your own server
• Not for: small machines, or treating its benchmark claims as checked without your own tests

On Hugging Face, 13 November 2026

• Task: text generation
• Library: transformers
• Parameters: 685B
• Weights: about 685 GB in F8_E4M3; about 343 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 8,260,197
• Likes: 1,597
• License: mit
• Based on: deepseek-ai/DeepSeek-V3.2-Exp-Base
• Quantized versions: 21
• Fine-tunes: 36
• Tags: transformers, safetensors, deepseek_v32, text-generation, fp8

Links

• Model: https://huggingface.co/deepseek-ai/DeepSeek-V3.2
• Files: https://huggingface.co/deepseek-ai/DeepSeek-V3.2/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download deepseek-ai/DeepSeek-V3.2

Then follow the usage in its model card. Nothing in this kit runs by itself.