DeepSeek dropped a new model yesterday. No warning. No teaser campaign. Just a quiet API update and a bunch of benchmark numbers that made me do a double take.
Here’s the thing about DeepSeek: they always do this. You’re sitting there, minding your own business, and suddenly they launch something that makes everyone else look slow. This time it’s a vision model. DeepSeek-V4-Flash-Vision-Exp. Finally.
I’ve been waiting for this. DeepSeek was the only major player without a proper multimodal model. Claude has it. OpenAI has it. Google has it. DeepSeek? Nothing. Until now.
Let me tell you what I found after testing it all night.
Wait, I Should Back Up
DeepSeek released a new multimodal vision model on their API platform. The name is a mouthful — DeepSeek-V4-Flash-Vision-Exp — but the important part is that it’s now available for anyone to try through the API. Set model=deepseek-v4-flash-vision-exp and you’re in.
The benchmarks look solid. On ApexBench, it scored 36.5 compared to Opus-4.8’s 39.4. On Chartography, it’s 64.3 versus 65.0. On Agents’ Last Exam and ZeroBench, it actually beat Opus by 1.6 and 1 point respectively.
But here’s what caught my attention.
Wait, It’s That Cheap?
The pricing is identical to DeepSeek-V4-Flash. Same price. No vision markup.
And the token calculation for images? Wild. A 1920×1080 image costs about 369 tokens. At peak pricing of 3 yuan per million input tokens, that’s roughly 0.0011 yuan per image. In USD, that’s about $0.00015.
Let me put that in perspective.
Most vision models charge based on image size. Bigger image = more tokens = more money. DeepSeek does something different. They resize everything to roughly 800×800 equivalent pixels. That means a 2000×2000 image and a 5000×5000 image cost the same. Each image maxes out at 384 tokens.
That’s ridiculous. In a good way.
What Can It Actually Do?
I threw a bunch of stuff at it. Screenshots of error messages. Graphs from financial reports. A messy UI design mockup I had lying around. A photo of a whiteboard with terrible handwriting.
The text extraction is solid. It read the error logs cleanly. It pulled numbers from charts without hallucinating. It even made sense of my messy whiteboard photo, which is honestly more than I expected.
But there’s something weird happening under the hood.
The Vision Model Made the Text Model Smarter?
This is the part that broke my brain.
DeepSeek-V4-Flash-Vision-Exp improved on text-only benchmarks. Not just vision tasks. Text tasks.
Look at the numbers: NL2Repo +3.5. DeepSWE +4.9. DSBench-Hard +4.0. Agents’ Last Exam +2.1. These are all text-based Agent benchmarks. No images involved. But the vision model still scored higher.
I actually wrote about this model right after it dropped — DeepSeek New Vision Model Is Here. Should You Care?. Back then I was mostly impressed by the Files API and the fact that it actually helped me debug a frontend issue in two minutes. But I didn’t dig into why the vision upgrade made the text model better too. Now I think I get it.
How does that work?
I’m not a researcher, but I think I get the logic.
When a model learns to see, it’s forced to understand spatial relationships. Layout. Structure. The physical world makes sense in a way that text alone doesn’t always capture. Writing code requires understanding structure. Navigating a repository requires understanding layout. Running tests requires understanding sequence.
Vision training teaches those things.
So the model isn’t just learning to read images. It’s learning a framework for understanding the world. And that framework transfers to text tasks. The spatial intelligence it picked up from images makes it better at reasoning about code, about files, about anything with structure.
Honestly? I didn’t expect that.
I tested this by running some of my own prompts. I asked it to analyze a messy codebase structure. It gave me a clean explanation of the dependencies and suggested improvements. Then I asked it to look at a graph and explain what the data meant. It did both well.
Here’s what actually matters.
What This Means for Normal People
If you’re not an AI researcher, here’s what you need to know.
First, you can now send images to DeepSeek through the API. Screenshots, charts, design files, whiteboard photos — all of it works. It reads text from images, analyzes charts, and reasons about visual information.
Second, it’s cheap. Ridiculously cheap. Like, you could upload thousands of images for pocket change.
Third, the vision upgrade seems to make the model smarter across the board. The improvements on text benchmarks suggest that visual training is more than just a gimmick. It’s actually making the model better at reasoning, structure, and problem-solving in general.
I was skeptical when I saw the announcement. Another vision model. Another benchmark chart. Whatever.
But this one is different.
Here’s the catch.
What You Should Know Before Trying It
This is an experimental model. The “Exp” in the name stands for experimental. That means things might break. The performance might fluctuate. It might not work for every use case.
Also, the vision token calculation is based on image dimensions after scaling. If you upload a tiny image, they scale it up. If you upload a massive one, they scale it down. The cap is 384 tokens per image, which keeps costs predictable.
DeepSeek provided a token calculator you can run locally if you want to estimate costs before sending requests.
I tried it with a few real-world examples. A screenshot of a web page. A data table. A sketch of a user interface. The responses were fast, accurate, and didn’t feel like they were guessing.
But I’m still not entirely sure I’m using it right.
I’ll be honest — I spent most of the night testing this, and I still have questions. How does it handle complex charts with lots of data points? Does it work with handwritten notes that are messy? What about low-resolution images?
I’ll keep using it and see how it goes. Might report back if I find something surprising.
Wait, one more thing.
The Deeper Pattern
This is the part that makes me think about AI differently.
Earlier this year, I remember DeepSeek’s founder saying that multimodality might not be the main path to AGI. That vision wasn’t the priority. That they were focused on reasoning and text.
But then they built a vision model anyway. And it made their text model better.
That tells me something important.
Maybe the path to AGI isn’t about adding more sensors. It’s about building better internal representations. The model that understands spatial structure is better at understanding everything else. It’s not that seeing makes it smarter. It’s that the process of learning to see forces it to organize its internal world.
I don’t know if that’s true. I could be wrong. I’m just a guy who stayed up all night testing an API.
But here’s what I think.
This model matters. Not because it beats Opus-4.8 on some benchmarks. Not because it’s cheap. It matters because it shows us something about how these systems actually learn.
The ability to see isn’t about vision. It’s about structure. And structure is everywhere.
Anyway. I need to get some sleep.
The short version: DeepSeek finally has a vision model. It’s cheap, it works well, and it somehow made the text model smarter in the process. If you’re building anything with AI, you should try it. If you’re just curious, it’s worth a look.
I’ll probably switch back to the text model for most tasks. Vision is nice to have, but most of what I do doesn’t involve images. Still, knowing it’s there — and knowing it’s this cheap — changes how I think about what’s possible.
Also, my cat sat on my keyboard while I was writing this. Not relevant. But it happened.
Let me know if you try it. Or don’t. Either way, I’ll be here, waiting for the next surprise launch.
