DeepSeek V4-Flash-Vision-Exp Deep Dive: A New Milestone for Open-Source Multimodal Agents

Saturday, August 22, 2026

1. Introduction: When DeepSeek Finally “Opens Its Eyes”

On the afternoon of August 21, 2026, a new model name quietly appeared on the DeepSeek API documentation page: deepseek-v4-flash-vision-exp. No grand launch event, no lengthy technical report—yet behind this single line of model name, the DeepSeek V4 series, for the first time, natively supports image input, officially transitioning from pure text to the multimodal era.

If the open-sourcing of DeepSeek Harness (August 13) was “giving AI hands and feet,” then the release of V4-Flash-Vision-Exp is “giving AI eyes.” The close temporal proximity of these two events is no coincidence—they collectively point to a larger ambition: building a complete open-source multimodal Agent infrastructure.

Before this release, the GitHub discussion board of DeepSeek Harness was flooded with one recurring question: “How do I make DeepSeek see images?” Developers uploading images would receive a blunt MODEL_DOES_NOT_SUPPORT_IMAGES error. The community had to build their own “vision bridge” plugins (such as dsh-deepseek-vision), routing images through Qwen-VL or other vision-language models first, then passing the text description to DeepSeek. This awkward “borrowing eyes” situation has finally come to an end with the arrival of V4-Flash-Vision-Exp.

2. The DeepSeek V4 Series Evolution: From Pure Text to Multimodal

2.1 V4 Family Model Overview

The DeepSeek V4 series was officially released on April 24, 2026, with a dual-flagship architecture:

┌──────────────────────────────────────────────────────────────────┐
│                    DeepSeek V4 Family Architecture                │
├──────────────────────────────────────────────────────────────────┤
│                                                                  │
│  V4-Pro (Flagship Reasoning)   V4-Flash (Efficient Reasoning)    │
│  ┌─────────────────────┐      ┌─────────────────────┐           │
│  │ Total Params: 1.6T  │      │ Total Params: 284B  │           │
│  │ Active Params: 49B  │      │ Active Params: 13B  │           │
│  │ Training Data: 33T  │      │ Training Data: 32T  │           │
│  │ Context: 1M         │      │ Context: 1M         │           │
│  └─────────────────────┘      └─────────────────────┘           │
│           │                           │                          │
│           └──────────┬────────────────┘                          │
│                      │                                           │
│           ┌──────────▼───────────┐                                │
│           │  Shared Architecture  │                                │
│           │  • MoE + Hybrid Attn  │                                │
│           │  • CSA + HCA Dual    │                                │
│           │    Compression        │                                │
│           │  • mHC (Manifold     │                                │
│           │    Hyper-Connections)│                                │
│           │  • mxFP4 Training    │                                │
│           │  • 3-Tier Reasoning  │                                │
│           │    Effort Control    │                                │
│           └──────────────────────┘                                │
│                                                                  │
│  2026-08-21: V4-Flash-Vision-Exp (Multimodal Experimental)       │
│               ┌──────────────────────────┐                       │
│               │ Text ≈ V4-Flash          │                       │
│               │ + Native Image Input     │                       │
│               │ + 1M Context / 384K Output│                       │
│               │ + Multimodal Agent Cap.  │                       │
│               └──────────────────────────┘                       │
└──────────────────────────────────────────────────────────────────┘

V4-Pro: 1.6 trillion total parameters, 49B active parameters per token, positioned as a flagship reasoning model. It achieved a Codeforces contest rating of 3,206 (ranked 23rd among humans) and 81% on SWE-bench Verified, representing the highest level of open-source reasoning capability.

V4-Flash: 284B total parameters, only 13B active parameters per token, positioned for high-throughput, low-cost deployment. It excels at Agent tasks with a Terminal Bench 2.1 score of 82.7, making it one of the most cost-effective open-source Agent models available.

Both are pure text models with 1M context windows, utilizing MoE + hybrid attention mechanisms (CSA + HCA), and introducing innovations such as manifold-constrained hyper-connections (mHC) and mxFP4 training precision.

2.2 From V4-Flash to Vision-Exp: Key Evolution Timeline

Timeline: DeepSeek V4 Series Key Milestones

2026-04-24  ──  V4 Preview Release (V4-Pro + V4-Flash, text-only)
                │
                │  • MIT License, fully open-source
                │  • 1M context, MoE architecture
                │  • No multimodal capability
                ▼
2026-07-31  ──  V4-Flash Official Public Beta
                │
                │  • Significantly enhanced Agent capabilities
                │  • Native Responses API support
                │  • Codex adaptation
                ▼
2026-08-13  ──  V4-Pro GA + DeepSeek Harness Open-Sourced
                │
                │  • Open-source Agent Harness (v0.1.0-rc.6)
                │  • Full plugin architecture (Cordis)
                │  • But models still lack image input support
                ▼
2026-08-14~20 ── Harness rc.7/rc.8 Updates
                │
                │  • Enhanced multimodal support
                │  • Model adapter now supports native image requests
                │  • Community "vision bridge" plugins emerge
                ▼
2026-08-21  ──  V4-Flash-Vision-Exp Released 🎯
                │
                │  • First native vision model
                │  • Files API launched simultaneously
                │  • Harness v0.1.1 with out-of-box support
                │  • Multimodal Agent performance close to Opus-4.8

2.3 Why V4-Flash, Not V4-Pro, for Vision?

This is a noteworthy product decision. The Vision Exp was placed in the V4-Flash product line rather than V4-Pro. This means DeepSeek is prioritizing bringing vision capabilities to the smaller, faster, cheaper model first.

V4-Flash has only 284B total parameters and 13B active parameters, designed for high-throughput, low-cost deployment. If the Vision version follows this positioning, its target use cases likely aren’t casual image chat, but rather the vast number of visual tasks that occur within Agent workflows—reading web page screenshots, identifying error interfaces, analyzing charts, examining software UIs, reviewing design drafts, and then performing actions based on what it sees. These tasks don’t necessarily require “the absolute best single-image understanding,” but they do care deeply about speed, price, and sustained operation.

3. V4-Flash-Vision-Exp Architecture Deep Dive

3.1 Architecture Hypothesis: Vision Frontend + Text Reasoning Pipeline

Although DeepSeek has not yet published a full technical report on Vision Exp, reasonable inferences can be drawn from available information:

┌──────────────────────────────────────────────────────────────────┐
│              V4-Flash-Vision-Exp Hypothetical Architecture        │
│                                                                  │
│  User Input                                                      │
│   ┌────────────────┐                                            │
│   │ Text + Image(s) │                                            │
│   └───────┬────────┘                                            │
│           │                                                      │
│           ▼                                                      │
│  ┌────────────────────┐                                          │
│  │  Vision Encoder     │  ← New Module                           │
│  │  ┌────────────────┐ │                                          │
│  │  │ Image Parsing   │ │  • JPEG/PNG/GIF/WebP                   │
│  │  │ Size Normalize  │ │  • 3 detail modes: low/original/auto   │
│  │  │ Token Conversion│ │  • Max 384 Tokens per image            │
│  │  └───────┬────────┘ │                                          │
│  └──────────┼──────────┘                                          │
│             │                                                    │
│             ▼                                                    │
│  ┌───────────────────────────────────────┐                       │
│  │  V4-Flash Core Inference Engine       │  ← Unchanged text     │
│  │  ┌──────────┐ ┌──────────┐           │    capabilities       │
│  │  │ CSA Attn │ │ HCA Attn │           │                       │
│  │  │ Compress │ │ Heavy    │           │                       │
│  │  │ Sparse   │ │ Compress │           │                       │
│  │  │ Attention│ │ Attention│           │                       │
│  │  └──────────┘ └──────────┘           │                       │
│  │  ┌───────────────────────────────┐   │                       │
│  │  │  MoE Experts (284B/13B active)│   │                       │
│  │  │  1 shared + 256 routed        │   │                       │
│  │  │  6 Experts activated per token│   │                       │
│  │  └───────────────────────────────┘   │                       │
│  └───────────────────────────────────────┘                       │
│             │                                                    │
│             ▼                                                    │
│  ┌────────────────────┐                                          │
│  │  Output (Text/JSON/ │                                          │
│  │  Tool Calls/       │                                          │
│  │  Responses API)    │                                          │
│  └────────────────────┘                                          │
│                                                                  │
│  ⚡ Key Features:                                                 │
│  • Vision tokens and text tokens priced uniformly                │
│  • Max 384 tokens per image                                      │
│  • Same price as V4-Flash (no vision surcharge)                  │
│  • Video input not supported                                     │
└──────────────────────────────────────────────────────────────────┘

Key Inference: Vision Exp is likely not an end-to-end unified native multimodal model, but rather a vision encoding module (Vision Encoder) connected to the front of the V4-Flash text inference engine. Images are converted to token sequences via the vision encoder, then concatenated with text tokens and fed into the V4-Flash core engine for unified inference. This architecture differs from Gemini and GPT series which emphasize unified multimodal pre-training, but offers advantages in engineering speed, cost, and preserving text-only performance.

3.2 Core Capability Matrix

┌──────────────────────────────────────────────────────────────────┐
│               V4-Flash-Vision-Exp Capability Map                  │
├───────────────────────┬──────────────────────────────────────────┤
│   Dimension            │               Specification              │
├───────────────────────┼──────────────────────────────────────────┤
│ Context Window         │ 1M Tokens                                │
│ Max Output Length      │ 384K Tokens                              │
│ Image Formats          │ JPEG / PNG / GIF / WebP                  │
│ Max Images Per Request │ 600 images                               │
│ Max Resolution         │ 8192 pixels (longest edge)               │
│ Max File Size          │ 64 MiB (Files API) / 32 MiB (inline)     │
│ Detail Mode            │ low (512×512) / original / auto(=original)│
│ Max Tokens Per Image   │ 384 Tokens                               │
│ API Formats            │ Chat Completions / Messages / Responses  │
│                       │ Anthropic API / Chat Prefix Completion    │
│ Supported Features     │ JSON Output / Tool Calls / Function Call │
│ Image Input Methods    │ Base64 inline / Public URL / Files API   │
│ Thinking Effort        │ low / high / max (3 tiers)               │
└───────────────────────┴──────────────────────────────────────────┘

3.3 Benchmark Analysis

DeepSeek published 11 benchmark results (using DeepSeek Harness minimal mode, max effort, temperature=1.0, top-p=0.95):

┌──────────────────────────┬──────────┬──────────┬──────────┐
│       Benchmark          │Vision-Exp│V4-Flash  │Opus-4.8  │
├──────────────────────────┼──────────┼──────────┼──────────┤
│ Terminal Bench 2.1       │   83.9   │   82.7   │   85.0   │
│ NL2Repo                  │   57.7   │   54.2   │   69.7   │
│ DeepSWE                  │   59.3   │   54.4   │   58.0   │
│ DSBench-Hard             │   63.6   │   59.6   │   71.7   │
│ AutomationBench (Public) │   25.7   │   25.1   │   27.2   │
│ ApexBench (Pass@1)       │   36.5   │   26.2*  │   39.4   │
│ Agents' Last Exam        │   27.3   │   25.2*  │   25.7   │
│ Chartography             │   64.3   │    —     │   65.0   │
│ ZeroBench (Pass@5)       │   35.0   │    —     │   34.0   │
│ Toolathlon-Verified      │   75.9   │   70.3   │   76.2   │
│ Cybergym                 │   75.3   │   76.7   │    —     │
└──────────────────────────┴──────────┴──────────┴──────────┘
* V4-Flash is text-only; in ApexBench and Agents' Last Exam, it ignores multimodal elements

Key Analysis:

Text Parity Maintained: On pure-text Agent benchmarks, Vision Exp performs on par with V4-Flash, and even slightly exceeds it on some metrics (Toolathlon-Verified +5.6, DeepSWE +4.9, DSBench-Hard +4.0), demonstrating that adding vision capability did not “drag down” text reasoning.
Multimodal Agent Leap: On vision-requiring benchmarks like ApexBench (UI operation), Vision Exp’s 36.5 points represent a nearly 40% improvement over V4-Flash’s 26.2, approaching Opus-4.8’s 39.4.
Gap to Opus-4.8: Vision Exp outperforms Opus-4.8 on 3 of 11 benchmarks (DeepSWE +1.3, Agents’ Last Exam +1.6, ZeroBench +1.0) and trails on the remaining 8, but most gaps are within 2 points. The largest gaps are in NL2Repo (12 points) and DSBench-Hard (8.1 points)—both repository-level coding tasks, suggesting room for improvement in complex programming scenarios.
Caveat: All results are from DeepSeek’s own testing. Third-party evaluations (Artificial Analysis, CLUE, Arena, etc.) have not yet been published. Reader discretion is advised.

4. Multimodal Agent Capabilities in Detail

4.1 From “Hearing Descriptions” to “Seeing Firsthand”: A Qualitative Change in Agent Capability

The core value of V4-Flash-Vision-Exp is not about “image captioning” or visual entertainment—it’s about embedding visual perception directly into the Agent workflow:

Traditional Text-Only Agent Workflow:
User Description → Text Understanding → Reasoning → Tool Calls → Execution

Multimodal Agent Workflow (Vision Exp):
Screenshot/Image → Visual Understanding → Text Understanding → Reasoning → Tool Calls → Execution
    ↑                                                                                    │
    └─────────────────────────────── Feedback Loop ──────────────────────────────────────┘

Typical Multimodal Agent Scenarios:

Scenario	Before (Text-Only)	Now (Vision Exp)
Web Automation Testing	Manually extract DOM element text	Direct screenshot, model understands UI layout
Error Diagnosis	User must manually copy error text	Screenshot error interface, auto-identify issues
Data Analysis	Requires structured data input	Read charts/screenshots directly, understand trends
Code Review	Can only see code text	See code + UI screenshots + design drafts simultaneously
Document Processing	Pure text parsing	Scan document images, extract tables/charts
Desktop Automation	Cannot perceive screen state	Screenshot to perceive current state and decide

4.2 Three Image Input Methods

┌──────────────────────────────────────────────────────────────────┐
│               Three Image Input Methods Comparison                │
├──────────────────┬──────────────────┬───────────────┬────────────┤
│   Method         │   Description     │   Advantages  │  Limits    │
├──────────────────┼──────────────────┼───────────────┼────────────┤
│ Base64 Inline    │ Encode image as  │ No extra      │ ≤32MiB per │
│                  │ Base64 in request│ storage needed │ file       │
│                  │ body             │ Good for ad-  │ High band- │
│                  │                  │ hoc use       │ width cost │
├──────────────────┼──────────────────┼───────────────┼────────────┤
│ Public URL       │ Pass image URL   │ No upload     │ URL must be│
│                  │                  │ Works with    │ accessible │
│                  │                  │ existing CDN  │ Network    │
│                  │                  │               │ dependent  │
├──────────────────┼──────────────────┼───────────────┼────────────┤
│ Files API        │ Upload first,    │ Reusable      │ Must pre-  │
│ (file_id)        │ reference via    │ Saves band-   │ upload     │
│                  │ file_id          │ width         │ Storage    │
│                  │                  │ ≤64MiB per    │ quota      │
│                  │                  │ file          │ (25GiB/user)│
└──────────────────┴──────────────────┴───────────────┴────────────┘

5. Files API and Harness Integration

5.1 Files API Deep Dive

The Files API, launched alongside the Vision model, provides file storage infrastructure for multimodal Agents:

┌──────────────────────────────────────────────────────────────────┐
│                    Files API Architecture                         │
│                                                                  │
│  User Upload       Files API Service           Vision Model      │
│  ┌──────┐         ┌──────────────┐          ┌──────────┐       │
│  │Image │─upload─▶│ File Storage │─read────▶│ Vision   │       │
│  │      │         │ ┌──────────┐ │  file_id │ Under-   │       │
│  │      │         │ │25GiB/user│ │          │ standing │       │
│  │      │         │ │Max 10000 │ │          │          │       │
│  │      │         │ │ files    │ │          │          │       │
│  │      │         │ └──────────┘ │          │          │       │
│  │      │◀──return──── file_id  │          │          │       │
│  └──────┘  file_id └──────────────┘          └──────────┘       │
│                                                                  │
│  Files API Specifications:                                       │
│  • Free to use (only model reading charges tokens)               │
│  • Supported formats: JPEG / PNG / GIF / WebP                    │
│  • Max file size: 64 MiB                                         │
│  • Storage quota: 25 GiB/user, up to 10,000 files                │
│  • Retention: 1 hour ~ 30 days (configurable), permanent if unset│
│  • Operations: Upload / List / Reference (file_id) / Delete      │
│  • No download API                                               │
└──────────────────────────────────────────────────────────────────┘

The key design advantage of Files API is free + reusable. The same image doesn’t need to be re-uploaded across multiple requests—just reference it via file_id, saving bandwidth and reducing latency. This is particularly useful for continuous analysis of long documents, web page screenshots, and multi-turn visual Agent tasks.

5.2 DeepSeek Harness Integration

Just one week after Vision Exp’s release, DeepSeek Harness was updated to v0.1.1 with out-of-box support for the new model:

┌──────────────────────────────────────────────────────────────────┐
│        DeepSeek Harness + Vision-Exp Integration Architecture    │
│                                                                  │
│  ┌──────────────────────────────────────────────────────────┐    │
│  │  DeepSeek Harness (v0.1.1)                               │    │
│  │  ┌────────────────────────────────────────────────────┐  │    │
│  │  │  Cordis Plugin Kernel                               │  │    │
│  │  │  ┌──────────────┐ ┌──────────────┐ ┌────────────┐  │  │    │
│  │  │  │Model Adapter │ │Tool Registry │ │Session Mgr │  │  │    │
│  │  │  │(Vision-Exp) │ │(File/Terminal│ │(Text+Image │  │  │    │
│  │  │  │(Default Viz)│ │ /Search/Code)│ │  Mixed)    │  │  │    │
│  │  │  └──────┬───────┘ └──────────────┘ └────────────┘  │  │    │
│  │  │         │                                           │  │    │
│  │  │  ┌──────▼───────────────────────────────────────┐  │  │    │
│  │  │  │  Multimodal Agent Loop                        │  │  │    │
│  │  │  │  ┌─────────┐ ┌─────────┐ ┌────────────────┐  │  │  │    │
│  │  │  │  │ /goal   │ │ /plan   │ │ @menu reference│  │  │  │    │
│  │  │  │  │ Text+Img│ │ Text+Img│ │ files & sess.  │  │  │  │    │
│  │  │  │  └─────────┘ └─────────┘ └────────────────┘  │  │  │    │
│  │  │  └───────────────────────────────────────────────┘  │  │    │
│  │  └────────────────────────────────────────────────────┘  │    │
│  │                                                          │    │
│  │  ┌────────────────────────────────────────────────────┐  │    │
│  │  │  Modes: Standard / PTC / Minimal / Creative        │  │    │
│  │  │  MCP/ACP: Image attachment persistence             │  │    │
│  │  │  PTC: Forward nested images                        │  │    │
│  │  └────────────────────────────────────────────────────┘  │    │
│  └──────────────────────────────────────────────────────────┘    │
│                                                                  │
│  ┌──────────────────────────┐                                    │
│  │  V4-Flash-Vision-Exp     │◀── Default vision model           │
│  │  (API: deepseek-v4-flash │                                    │
│  │   -vision-exp)           │                                    │
│  └──────────────────────────┘                                    │
└──────────────────────────────────────────────────────────────────┘

Key Harness update highlights:

Model list updated to support Vision Exp, set as default vision model
/goal, /plan commands support mixed text+image input
@ menu can reference files and sessions containing images
MCP/ACP supports image attachment persistence
PTC Mode supports forwarding nested images
Fixed issues with oversized images and excessive historical image payload causing request failures

6. Code Examples: Hands-On Practice

6.1 Python: Calling V4-Flash-Vision-Exp for Multimodal Understanding

import requests
import base64
import json

# DeepSeek API Configuration
API_KEY = "sk-your-deepseek-api-key"
BASE_URL = "https://api.deepseek.com/v1"

def encode_image(file_path):
    """Encode image file to Base64"""
    with open(file_path, "rb") as f:
        return base64.b64encode(f.read()).decode("utf-8")

def vision_agent_invoke(image_path, prompt, model="deepseek-v4-flash-vision-exp"):
    """
    Multimodal Agent invocation: image + text prompt, returns model understanding
    """
    base64_image = encode_image(image_path)
    
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": model,
        "messages": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/png;base64,{base64_image}",
                            "detail": "auto"  # low/original/auto
                        }
                    },
                    {
                        "type": "text",
                        "text": prompt
                    }
                ]
            }
        ],
        "max_tokens": 4096,
        "temperature": 0.7
    }
    
    response = requests.post(
        f"{BASE_URL}/chat/completions",
        headers=headers,
        json=payload
    )
    
    return response.json()

# Example: Analyze a dashboard screenshot and execute actions
result = vision_agent_invoke(
    image_path="./screenshot_dashboard.png",
    prompt="""Analyze this dashboard screenshot and complete the following tasks:
1. Extract all visible KPI metrics and their values
2. Identify chart types and data trends
3. Determine if any anomalous data points exist
4. If anomalies are found, provide troubleshooting recommendations"""
)

print(json.dumps(result, indent=2, ensure_ascii=False))

6.2 Python: Using Files API for Image Reuse

import requests

def upload_file_to_deepseek(file_path, purpose="vision"):
    """Upload file to DeepSeek Files API, returns file_id"""
    headers = {
        "Authorization": f"Bearer {API_KEY}"
    }
    
    with open(file_path, "rb") as f:
        files = {"file": f}
        data = {"purpose": purpose}
        
        response = requests.post(
            f"{BASE_URL}/files",
            headers=headers,
            files=files,
            data=data
        )
    
    return response.json()["id"]  # Returns file_id

def list_files():
    """List all uploaded files"""
    headers = {"Authorization": f"Bearer {API_KEY}"}
    response = requests.get(f"{BASE_URL}/files", headers=headers)
    return response.json()

def delete_file(file_id):
    """Delete an uploaded file"""
    headers = {"Authorization": f"Bearer {API_KEY}"}
    response = requests.delete(
        f"{BASE_URL}/files/{file_id}",
        headers=headers
    )
    return response.status_code == 204

# Use file_id to reference images across multiple turns
file_id = upload_file_to_deepseek("./chart_analysis.png")

# Turn 1: Analyze chart
response1 = requests.post(
    f"{BASE_URL}/chat/completions",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={
        "model": "deepseek-v4-flash-vision-exp",
        "messages": [{
            "role": "user",
            "content": [
                {"type": "file_id", "file_id": file_id},
                {"type": "text", "text": "Analyze the data trends in this chart"}
            ]
        }]
    }
)

# Turn 2: Follow-up on the same image (no re-upload needed)
response2 = requests.post(
    f"{BASE_URL}/chat/completions",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={
        "model": "deepseek-v4-flash-vision-exp",
        "messages": [{
            "role": "user",
            "content": [
                {"type": "file_id", "file_id": file_id},
                {"type": "text", "text": "Based on the anomalous data points, provide troubleshooting suggestions"}
            ]
        }]
    }
)

6.3 Python: Tool Calls + Visual Understanding

def multimodal_agent_with_tools():
    """
    Multimodal Agent: Visual Understanding + Tool Calling
    Scenario: Read error screenshot -> Search for solution -> Generate fix code
    """
    error_screenshot = "./error_screenshot.png"
    file_id = upload_file_to_deepseek(error_screenshot)
    
    # Step 1: Identify the error
    identify_response = requests.post(
        f"{BASE_URL}/chat/completions",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={
            "model": "deepseek-v4-flash-vision-exp",
            "messages": [{
                "role": "user",
                "content": [
                    {"type": "file_id", "file_id": file_id},
                    {
                        "type": "text",
                        "text": "Identify the error information in this screenshot."
                                "Extract the error type, error code, and key stack trace info"
                    }
                ]
            }],
            "tools": [{
                "type": "function",
                "function": {
                    "name": "search_web",
                    "description": "Search the internet for information",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "query": {
                                "type": "string",
                                "description": "Search keywords"
                            }
                        },
                        "required": ["query"]
                    }
                }
            }],
            "tool_choice": "auto"
        }
    )
    
    return identify_response.json()

# Execute multimodal Agent
result = multimodal_agent_with_tools()
print(result["choices"][0]["message"]["content"])

6.4 Go: Responses API Call Example

package main

import (
    "bytes"
    "encoding/base64"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

type VisionRequest struct {
    Model    string        `json:"model"`
    Messages []Message     `json:"messages"`
    MaxTokens int          `json:"max_tokens"`
}

type Message struct {
    Role    string    `json:"role"`
    Content []Content `json:"content"`
}

type Content struct {
    Type     string      `json:"type"`
    Text     string      `json:"text,omitempty"`
    ImageURL *ImageURL   `json:"image_url,omitempty"`
}

type ImageURL struct {
    URL    string `json:"url"`
    Detail string `json:"detail"`
}

func main() {
    apiKey := "sk-your-deepseek-api-key"
    
    // Read and encode image
    imgData, _ := ioutil.ReadFile("./chart.png")
    base64Img := base64.StdEncoding.EncodeToString(imgData)
    
    // Build request body
    reqBody := VisionRequest{
        Model: "deepseek-v4-flash-vision-exp",
        Messages: []Message{
            {
                Role: "user",
                Content: []Content{
                    {
                        Type: "image_url",
                        ImageURL: &ImageURL{
                            URL:    fmt.Sprintf("data:image/png;base64,%s", base64Img),
                            Detail: "high",
                        },
                    },
                    {
                        Type: "text",
                        Text: "Analyze this chart and extract key data points and trends",
                    },
                },
            },
        },
        MaxTokens: 4096,
    }
    
    body, _ := json.Marshal(reqBody)
    
    // Send request
    req, _ := http.NewRequest("POST",
        "https://api.deepseek.com/v1/responses",
        bytes.NewBuffer(body))
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{}
    resp, _ := client.Do(req)
    
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    
    fmt.Printf("%+v\n", result)
}

6.5 DeepSeek Harness Configuration: Integrating Vision-Exp

# harness-config.yaml
# DeepSeek Harness Model Configuration - Enable Vision-Exp

models:
  default: deepseek-v4-flash-vision-exp
  
  providers:
    deepseek:
      api_key: ${DEEPSEEK_API_KEY}
      base_url: https://api.deepseek.com/v1
      models:
        - name: deepseek-v4-flash-vision-exp
          multimodal: true  # Enable multimodal support
          max_images: 600   # Max images per request
          image_size_limit: 64  # MiB
          supports_files_api: true
          
        - name: deepseek-v4-flash
          multimodal: false  # Text-only model
          
        - name: deepseek-v4-pro
          multimodal: false

agent:
  mode: standard  # standard / ptc / minimal / creative
  
  # Vision Agent configuration
  vision:
    default_detail: auto  # low / original / auto
    max_image_tokens: 384  # Max tokens per image
    enable_file_referencing: true  # Enable Files API reference
    auto_compress_large_images: true  # Auto-compress large images
    
  tools:
    - file_editor
    - terminal
    - web_search
    - code_executor
    - image_analysis  # New: image analysis tool

7. Pricing and Cost-Effectiveness Analysis

7.1 Pricing Model

V4-Flash-Vision-Exp’s API pricing is identical to V4-Flash—no price increase for the added vision capability:

┌──────────────────────────────────────────────────────────────────┐
│              V4-Flash-Vision-Exp Pricing (per million tokens)    │
├──────────────────────┬──────────────────────┬────────────────────┤
│     Billing Item      │   Off-Peak           │   Peak             │
│                      │   (00:00-09:00,      │   (09:00-12:00,    │
│                      │    18:00-24:00)      │    14:00-18:00)    │
├──────────────────────┼──────────────────────┼────────────────────┤
│ Input (Cache Hit)    │   0.05 CNY           │   0.10 CNY         │
│ Input (Cache Miss)   │   1.5 CNY            │   3.0 CNY          │
│ Output               │   4.5 CNY            │   9.0 CNY          │
├──────────────────────┴──────────────────────┴────────────────────┤
│                                                                  │
│  Image Token Calculation:                                        │
│  • low mode: Scale to 512×512, fixed token consumption           │
│  • original/auto mode: Converted by actual size, max 384 tokens  │
│  • Minimum cost per image: 384 × 1.5/1e6 ≈ 0.000576 CNY         │
│    (~0.00008 USD per image)                                      │
│  • Peak hours: ~0.00016 USD per image                            │
└──────────────────────────────────────────────────────────────────┘

7.2 Competitor Price Comparison

┌──────────────────────┬──────────────┬──────────────┬───────────────┐
│       Model          │ Input Price   │ Output Price │ Vision        │
│                      │ (per million) │ (per million)│ Surcharge     │
├──────────────────────┼──────────────┼──────────────┼───────────────┤
│ DeepSeek V4-         │ 1.5~3 CNY    │ 4.5~9 CNY   │ None (image   │
│ Flash-Vision-Exp     │ (off~peak)  │ (off~peak)  │ → token,      │
│                      │              │              │ unified billing)│
├──────────────────────┼──────────────┼──────────────┼───────────────┤
│ GPT-5.6 Sol Vision   │ ~$15/M       │ ~$60/M       │ Separate image│
│                      │ (~105 CNY)   │ (~420 CNY)   │ pricing       │
├──────────────────────┼──────────────┼──────────────┼───────────────┤
│ Gemini 3.7 Flash     │ ~$0.15/M     │ ~$0.60/M     │ Per-image size│
│                      │ (~1.05 CNY)  │ (~4.2 CNY)   │ extra charge  │
├──────────────────────┼──────────────┼──────────────┼───────────────┤
│ Qwen3.8-VL           │ ~¥2/M        │ ~¥8/M        │ None (unified)│
├──────────────────────┼──────────────┼──────────────┼───────────────┤
│ Opus-4.8             │ ~$5/M        │ ~$55/M       │ Per-image     │
│                      │ (~35 CNY)    │ (~385 CNY)   │ token billing │
└──────────────────────┴──────────────┴──────────────┴───────────────┘

Cost-Effectiveness Analysis:

vs Opus-4.8: DeepSeek’s input price is approximately 1/23 of Opus-4.8, output price about 1/43. With multimodal Agent performance approaching Opus-4.8, the cost advantage is dramatic.
vs GPT-5.6 Sol Vision: DeepSeek’s input price is roughly 1/70, output about 1/47. For high-volume visual Agent deployments, the cost advantage is overwhelming.
vs Gemini 3.7 Flash: While Gemini Flash has lower input pricing, output pricing is similar, and Gemini applies additional image-based charges. DeepSeek’s unified image-to-token billing is more transparent for developers.
vs Qwen3.8-VL: Similar pricing, but DeepSeek has a clear advantage in Agent capabilities.

7.3 The Strategic Meaning of Peak/Off-Peak Pricing

DeepSeek’s peak/off-peak pricing (peak hours at 2× off-peak), introduced on August 13, is a relatively uncommon strategy in API pricing. The logic behind it:

Incentivize off-peak scheduling: Non-critical tasks can be shifted to off-peak hours, reducing user costs while balancing server load
Extreme discount for cache hits: Off-peak cache hits cost only 0.05 CNY per million tokens—ideal for high-frequency repetitive vision tasks (e.g., batch analysis of similar screenshots)
Paving the way for large-scale Agent deployment: For production Agents running 24/7, intelligent scheduling can keep costs at extremely low levels

8. Competitive Landscape

8.1 Multimodal Model Comparison

┌──────────────────────┬──────────┬────────────┬──────────┬──────────┐
│       Dimension      │ DeepSeek │ GPT-5.6    │ Gemini   │ Qwen3.8 │
│                      │ V4-Flash │ Sol Vision │ 3.7 Flash│ -VL     │
│                      │ -Vision  │            │          │         │
├──────────────────────┼──────────┼────────────┼──────────┼──────────┤
│ Open Source          │  ❌(API) │    ❌      │    ❌    │  ✅(partial)│
│ Context Window       │  1M      │  1M        │  2M      │  128K   │
│ Max Output Length    │  384K    │  128K      │  64K     │  32K    │
│ Image Formats        │  4 types │  Multiple  │  Multiple│  Multiple│
│ Video Input          │  ❌      │  ✅        │  ✅      │  ❌     │
│ Agent Capability     │  🟢Strong│  🟢Strong  │  🟡Medium│  🟡Medium│
│ Tool Calling         │  ✅      │  ✅        │  ✅      │  ✅     │
│ JSON Output          │  ✅      │  ✅        │  ✅      │  ✅     │
│ Responses API        │  ✅      │  ✅        │  ❌      │  ❌     │
│ Anthropic API Compat │  ✅      │  ❌        │  ❌      │  ❌     │
│ Files API            │  ✅(Free)│  ✅(Paid)  │  ✅(Paid)│  ❌     │
│ Price (Input/Output, │ 1.5~3/   │ ~105/~420  │ ~1.05/   │ ~2/~8   │
│ CNY/M tokens)        │ 4.5~9   │            │ ~4.2     │         │
│ Peak/Off-Peak Pricing│  ✅      │  ❌        │  ❌      │  ❌     │
│ Domestic AI Hardware │  ✅(Ascend)│ ❌        │  ❌      │  ✅     │
└──────────────────────┴──────────┴────────────┴──────────┴──────────┘

8.2 Core Differentiation Analysis

vs GPT-5.6 Sol Vision: GPT-5.6 Sol Vision is OpenAI’s latest multimodal model, still leading in overall capability. However, DeepSeek’s differentiation lies in:

Agent-First Design: Vision Exp is architecturally designed for Agent scenarios, with natural advantages in tool calling, long context, and multi-turn interaction
Extreme Value: Priced at roughly 1/50 of GPT-5.6 Sol Vision
API Compatibility: Supports OpenAI Chat Completions, Responses API, and Anthropic API formats simultaneously—minimal migration cost

vs Gemini 3.7 Flash: Gemini 3.7 Flash maintains advantages in native multimodal capabilities (especially video understanding), but in Agent scenarios:

Despite its larger context window (2M), its tool-calling support is less mature than DeepSeek’s
Doesn’t support Responses API or Anthropic API formats
Output pricing is similar to DeepSeek, but the low input price advantage is partially offset by additional image-based charges

vs Qwen3.8-VL: Alibaba’s Qwen3.8-VL is competitive in Chinese-language scenarios:

Similar pricing, but Qwen’s context window (128K) is far smaller than DeepSeek’s (1M)
Significant gap in Agent capabilities, especially in complex tool calling and long-duration task execution
DeepSeek’s free Files API strategy is more attractive

8.3 Open-Source Ecosystem

While Vision Exp itself hasn’t been open-sourced (only available via API), the full open-sourcing of DeepSeek Harness (MIT license) provides critical ecosystem support. In contrast, GPT-5.6 Sol Vision and Gemini 3.7 Flash are both closed-source, preventing developers from deep customization at the framework level.

9. Industry Impact and Future Outlook

9.1 Impact on the Multimodal Agent Landscape

The release of V4-Flash-Vision-Exp marks a new phase for open-source multimodal Agents:

Lowering the barrier to multimodal Agent development: Previously, building a “seeing” Agent required combining at least two models (vision model + reasoning model). Now, a single API call suffices. The free Files API further reduces storage and bandwidth costs.
Accelerating the visual evolution of Agent tools: With Harness’s native support for vision capabilities, more Agent tools will naturally incorporate visual perception—terminal operations can be combined with screenshot understanding, code editing can incorporate UI design drafts, and search can incorporate image content.
Completing the “See-Think-Act” loop: DeepSeek is building not just a vision model, but a complete “Perceive-Reason-Act” loop:

               DeepSeek Multimodal Agent Loop
                   
               ┌───────────────┐
               │  Perceive      │
               │  V4-Flash-    │
               │  Vision-Exp   │
               │  Images/Charts │
               └───────┬───────┘
                       │
                       ▼
               ┌───────────────┐
               │  Reason        │
               │  V4-Flash Core │
               │  Inference     │
               │  1M Context   │
               └───────┬───────┘
                       │
                       ▼
               ┌───────────────┐
               │  Act           │
               │  DeepSeek      │
               │  Harness       │
               │  Tools/Code/   │
               │  Terminal      │
               └───────┬───────┘
                       │
                       └─────────► Feedback Loop

9.2 Limitations and Open Questions

Experimental (Exp suffix): Not recommended for production use; APIs and behavior may change
Image-only: No video input support—a gap in multimodal perception
Architecture opacity: No technical report published; key details (vision encoder architecture, training methodology, parameter count) are missing
Third-party validation pending: Official benchmarks need independent verification
Minor text-task regression: On Cybergym (security benchmark), Vision Exp scores 1.4 points lower than V4-Flash, suggesting vision capability has a minor impact on certain pure-text tasks

9.3 Future Outlook

Based on DeepSeek’s product roadmap and industry trends, reasonable expectations include:

Official release (non-Exp): Expected within 1-2 months, following community feedback and iteration, likely accompanied by a technical report
V4-Pro-Vision possibility: Bringing vision capabilities to V4-Pro for a stronger multimodal flagship
Video understanding: A natural direction in the medium-to-long term
Model open-sourcing: Following DeepSeek’s consistent open-source strategy, an open-weight model after the official release is a strong possibility
Competition with Claude Code/Codex: As the Harness + Vision-Exp combination matures, it will directly compete with Claude Code and OpenAI Codex

10. Developer Practice Guide

10.1 Getting Started Roadmap

For developers looking to quickly get hands-on with V4-Flash-Vision-Exp, the following step-by-step approach is recommended:

Environment Setup: Obtain a DeepSeek API key and ensure your account has sufficient balance (recommend at least 50 CNY for testing purposes)
Basic Call Testing: Use the Python SDK or cURL to test single-image visual understanding, verifying the model correctly identifies your image content
Files API Integration: Upload frequently used images to the Files API, reference them via file_id, and observe the effect of image reuse across multi-turn conversations
Harness Local Deployment: Install DeepSeek Harness v0.1.1 or later, configure Vision-Exp as the default vision model, and experience mixed text-image Agent workflows
Scenario Development: Choose your most familiar Agent scenario (web automation, error diagnosis, data analysis, etc.) and build a complete “visual understanding → reasoning → tool calling” loop

10.2 Best Practices

Image Preprocessing: For large images (>4K resolution), compress before uploading to avoid unnecessary token consumption. The 384-token per image cap means very large images may be downscaled significantly
Cache Strategy: For high-frequency repetitive vision tasks (e.g., monitoring dashboard screenshot analysis), leverage the cache hit mechanism (off-peak: only 0.05 CNY per million tokens) and schedule tasks during off-peak hours
Detail Mode Selection: Use low mode for simple icon recognition to save tokens, original mode for chart analysis to preserve details, and auto mode when uncertain to let the system decide
Multi-Image Composition: Up to 600 images per request are supported, ideal for batch screenshot comparison analysis—but be mindful of total token consumption
Error Handling: Implement retry logic and degradation strategies (e.g., fallback to text-only mode when image loading fails) in your code

10.3 Pitfalls to Avoid

The Exp version’s API interface may change; do not rely on current API behavior for critical production tasks
Video input is not supported; for video understanding needs, you’ll still need to combine with other models or split video frames manually
Files API storage is limited (25 GiB per user); clean up files you no longer need regularly to avoid upload failures due to full storage
Image token conversion rules may be adjusted in the future; monitor official documentation updates
Third-party evaluations are not yet published; official benchmark data should be used as reference only, not as the sole criterion for model selection

11. Conclusion

The release of DeepSeek V4-Flash-Vision-Exp is less about the launch of a “vision model” and more about the critical missing piece in DeepSeek’s multimodal Agent infrastructure—it’s what connects models, images, files, tools, and the Agent execution chain into a unified system.

Three Key Takeaways:

Text capability intact: Pure-text Agent, reasoning, and world knowledge capabilities are on par with V4-Flash—adding vision didn’t “drag down” text reasoning
Multimodal Agent leap: Major improvement on vision-requiring Agent benchmarks, approaching Opus-4.8 levels
Extreme value: Identical pricing to V4-Flash, with vision understanding costing as little as ~0.00008 USD per image—a significant cost advantage for Agent scenarios

For developers, now is the perfect time to experiment—the Exp version, while not recommended for production, is ideal for exploring multimodal Agent possibilities in real-world scenarios and providing feedback to DeepSeek. After all, an open-source Agent ecosystem that can truly “see” is just beginning.

References: DeepSeek API Official Change Log (api-docs.deepseek.com/updates/), 36Kr, Phoenix New Media, InfoQ, The Beijing News, IT Home, The Next Web