DeepSeek V4 Flash Vision Is Now Open Weight: MIT Release Lands on Hugging Face

DeepSeek-V4-Flash-Vision-Exp is no longer an API-only experiment. On August 31, 2026, DeepSeek published the model's official weights, tokenizer, prompt encoder, and reference inference code on Hugging Face under the MIT License.

That corrects an important piece of information that was true only ten days earlier. When the model launched on August 21, DeepSeek announced access through its API. The downloadable repository did not yet exist. Articles that described the model as closed or API-only at launch were accurate then, but they are outdated now.

Quick answer: DeepSeek-V4-Flash-Vision-Exp is now an openly downloadable, MIT-licensed multimodal model. Its official Hugging Face repository contains approximately 304.65 billion parameters, around 168GB of repository data, 48 safetensors weight shards, visual modules, prompt-encoding code, and a minimal PyTorch inference implementation.

DeepSeek V4 Flash Vision open-weights release at a glance

The official Hugging Face model page identifies the repository as MIT-licensed, lists the model at roughly 305B parameters, and describes it as DeepSeek's first experimental multimodal model in the V4 family.

The release happened in two stages

The timeline explains why recent reports appear to contradict one another.

August 21: the API release

DeepSeek's August 21 announcement introduced deepseek-v4-flash-vision-exp on the DeepSeek API Platform.

At that stage, developers could call the experimental multimodal model through Chat Completions, Messages, and Responses. DeepSeek documented three image-input methods: inline base64 data, external image URLs, and reusable uploads through its Files API. The API supports JPEG, PNG, GIF, and WebP inputs, with the service detecting the actual file content rather than trusting the filename.

The launch announcement focused on the hosted model and its multimodal-agent performance. It did not provide official downloadable weights.

August 31: weights and inference code

The Hugging Face API records the official repository's creation time as August 31, 2026. The repository is public, not gated, and tagged with an MIT license.

This second release changes the model's status in a meaningful way:

August 21
DeepSeek API access
        ↓
August 31
Official model weights
+ tokenizer
+ prompt encoding
+ vision encoder
+ aligner
+ reference inference code
+ MIT License

It is now possible to download, inspect, modify, and self-host the released checkpoint subject to the license and the practical limits of the required compute.

This is not just an adapter release

The repository is more substantial than a small vision adapter attached to an unavailable base model.

DeepSeek's model card says it includes:

• The tokenizer and tokenizer configuration
• OpenAI-style message-to-prompt encoding
• Text and JSON multimodal prompt examples
• A vision encoder
• A vision-to-language aligner
• DFlash attention
• Mixture-of-Experts routing
• Hyper-Connections
• The DSpark forward path
• Weight-conversion utilities
• A minimal PyTorch inference loop
• The complete safetensors index and model shards

The visible model files are named from:

model-00001-of-00048.safetensors

through 48 shards, accompanied by model.safetensors.index.json.

The repository's reference implementation is deliberately described as readable, minimal inference code—not a production serving engine. That distinction should prevent two common misunderstandings: the code is real and useful for inspection, but it is not automatically an optimized replacement for vLLM, SGLang, TensorRT-LLM, or a managed inference platform.

What does the 305B parameter count mean?

Hugging Face's safetensors metadata reports a total of 304,646,824,126 parameters. The repository uses mixed stored data types, and DeepSeek's inference configuration identifies FP8 model storage with FP4 expert weights.

The model remains a large Mixture-of-Experts architecture. The published reference configuration includes:

An MoE model does not activate every parameter for every token, so its compute per generated token is not equivalent to a dense 305B model. However, total checkpoint storage and memory placement still matter. The Hugging Face file browser showed a repository size of approximately 168GB at release time.

That leads to the most important deployment caveat:

Open weights do not mean consumer-hardware weights.

DeepSeek's example conversion and inference workflow uses tensor parallelism with MP=4. The documentation provides multi-node torchrun instructions as well. It does not claim that a single consumer GPU or a typical laptop can run the full model.

What the official local inference path looks like

The reference runtime currently requires packages including PyTorch 2.10 or newer, Transformers newer than version 5, safetensors 0.7, TileLang, Pillow, and fast_hadamard_transform.

The documented process is:

1. Download the Hugging Face checkpoint.
2. Install the reference runtime requirements.
3. Convert the Hugging Face weights into one checkpoint per tensor-parallel rank.
4. Run the included multimodal text or JSON examples.
5. Launch interactive generation with torchrun.

The official example uses four model-parallel ranks:

export HF_CKPT_PATH=/path/to/DeepSeek-V4-Flash-Vision-Exp-HF
export SAVE_PATH=/path/to/DeepSeek-V4-Flash-Vision-Exp-TP4
export MP=4

python convert.py \
  --hf-ckpt-path "${HF_CKPT_PATH}" \
  --save-path "${SAVE_PATH}" \
  --n-experts 256 \
  --model-parallel "${MP}" \
  --expert-dtype fp4

Interactive generation then uses the converted checkpoint:

torchrun --nproc-per-node "${MP}" generate.py \
  --ckpt-path "${SAVE_PATH}" \
  --config config.json \
  --interactive \
  --temperature 1.0

These commands prove that DeepSeek supplied a self-hosting path. They do not establish a minimum VRAM requirement, production throughput, or compatibility with every serving engine.

DeepSeek's official benchmark results

DeepSeek positions the release as a multimodal agent model, not merely an image-captioning model.

The official model card reports:

On DeepSeek's reported numbers, the vision model exceeds Opus 4.8 on DeepSWE, Agents' Last Exam, and ZeroBench Pass@5, while remaining behind it on several other tests.

These results require careful wording. They are vendor-published benchmark results, not independent confirmation that DeepSeek V4 Flash Vision is better than Opus 4.8 across real workloads.

DeepSeek also discloses part of its evaluation setup. For text-agent benchmarks, its models used DeepSeek Harness in minimal mode, maximum reasoning effort, temperature=1.0, and top_p=0.95. DeepSeek-V4-Flash-0731 ignored multimodal elements in ApexBench and Agents' Last Exam, which helps explain the larger vision-model gain on those evaluations.

Why vision matters for coding agents

Many software-development tasks are no longer text-only. An agent may need to understand:

• A failed browser screenshot
• A dashboard or chart
• A Figma export
• A mobile UI reference
• A scanned technical document
• A terminal image from a remote environment
• A before-and-after visual regression
• A diagram embedded in an issue

Text-only coding models need a separate vision tool or another model to translate those images into text. A native multimodal model can keep visual context inside the same reasoning loop.

That is why DeepSeek compares the model on agent and software-engineering evaluations rather than only visual question answering. The release is particularly relevant to terminal agents, browser agents, and software-development harnesses that already accept image attachments.

DeepSeek's own DSHPlugin ecosystem guide on AI IDE List explains the surrounding harness and plugin architecture. You can also compare the model's potential role with the extensible Pi coding agent, or examine how open models are packaged and run in our GPT-OSS hardware and local setup guide.

API access versus self-hosting

Developers now have two distinct routes.

DeepSeek API

The hosted API is the practical option for most users today. DeepSeek documents:

• Chat Completions, Messages, and Responses endpoints
• Mixed text and image messages
• Base64 images
• Public image URLs
• Reusable Files API uploads
• JPEG, PNG, GIF, and WebP input
• Up to 384 billed tokens per image

It avoids downloading a roughly 168GB repository and operating a large tensor-parallel inference stack.

Self-hosted weights

The Hugging Face release offers control over:

• Model inspection
• Private deployment
• Custom serving and scheduling
• Research modifications
• Quantization experiments
• Integration into internal infrastructure
• Reproducible testing without a hosted model dependency

That control comes with hardware, deployment, and optimization work.

When checked on release day, Hugging Face showed no hosted Inference Provider deployment for the model. The DeepSeek API remained the immediate managed route.

Does it work with vLLM, SGLang, or Ollama?

The official release does not yet establish broad plug-and-play support across those runtimes.

The repository provides DeepSeek's minimal PyTorch implementation and uses custom elements including its vision encoder, aligner, DFlash path, MoE implementation, Hyper-Connections, DSpark path, packed expert weights, and prompt encoding.

That means compatibility requires more than recognizing the model name. A serving engine must correctly implement the architecture, multimodal input format, weight layout, vision preprocessing, and generation behavior.

The safe release-day answer is:

Community support may arrive quickly, but users should verify an implementation rather than assuming compatibility from support for the text-only V4 Flash model.

Is it accurate to call the model open source?

“Open-source model” can be a contested term because model weights, training data, training code, and inference code are different artifacts.

For this release, the precise confirmed statement is strong:

DeepSeek released the model weights and reference inference repository under the MIT License.

The model is not gated, the checkpoint is downloadable, and the repository includes much more than an API client. Calling it an open-weight model with MIT-licensed inference code is therefore both accurate and specific.

The release does not, by itself, mean that DeepSeek published every training dataset, every training-stage implementation, or a complete recipe to reproduce the model from scratch.

What changed for developers on August 31?

Before the weight release, developers could:

• Send images to the DeepSeek API
• Use the model inside supported API clients
• Evaluate its hosted behavior
• Build vision tools around the API

After the weight release, developers can also:

• Inspect the architecture and preprocessing implementation
• Download the full checkpoint
• Run the supplied local inference path
• Build private deployments
• Develop optimized runtime support
• Create quantized derivatives where permitted
• Audit how image content becomes model tokens
• Test integrations without depending exclusively on the hosted endpoint

That is a material change, not a documentation update.

Frequently asked questions

Is DeepSeek-V4-Flash-Vision-Exp open weight now?

Yes. DeepSeek published the official checkpoint on Hugging Face on August 31, 2026. The repository is public, not gated, and MIT-licensed.

How large is DeepSeek V4 Flash Vision?

Hugging Face reports 304,646,824,126 parameters and approximately 168GB of repository storage at release time. The checkpoint is split across 48 safetensors files.

Can DeepSeek V4 Flash Vision run locally?

Yes, in the sense that DeepSeek provides downloadable weights and a local PyTorch inference implementation. The official example uses four-way tensor parallelism. DeepSeek has not described it as a consumer-GPU model.

Can it run on one GPU?

The official release does not provide a validated single-GPU configuration. Given the checkpoint size, users should not assume ordinary desktop-GPU compatibility.

Is there an Ollama model?

No official Ollama package is identified in the release-day model card. Third-party conversions should be evaluated separately for architecture support and correctness.

Does the model accept images through the API?

Yes. DeepSeek supports base64 images, external URLs, and Files API references in compatible endpoints.

Is the model better than Opus 4.8?

DeepSeek reports higher results on a few listed benchmarks and lower results on others. Those are official vendor results, not a general proof that one model is better across real tasks.

Final assessment

The most important DeepSeek V4 Flash Vision news on August 31 is not a new benchmark number. It is the transition from a hosted experimental endpoint to an inspectable and self-hostable model release.

API-only experiment
        ↓
MIT-licensed weights
+ vision modules
+ prompt encoder
+ reference inference code

For most developers, the DeepSeek API will remain easier than operating a 305B-parameter MoE checkpoint. For model-runtime teams, researchers, private-infrastructure operators, and agent-framework developers, the open weights create a much larger opportunity.

The information to update is simple: DeepSeek-V4-Flash-Vision-Exp was API-only on August 21. It has official downloadable weights as of August 31, 2026.

Official sources

• DeepSeek-V4-Flash-Vision-Exp on Hugging Face
• DeepSeek API release announcement
• DeepSeek Vision API guide

Last verified: August 31, 2026. Repository size, runtime support, hosted providers, and community conversions can change quickly.