DeepSeek's Model Spent Weeks Pretending It Could See. Now It Can.

Here's a fun thing that was happening to people for the past few weeks: you'd hand DeepSeek V4 Flash a screenshot, and it would confidently try to read it. It would invent an image-analysis tool that didn't exist, write code to parse pixels, sometimes pull screenshots off a connected device entirely on its own — and then hit the wall. Oh right. I can't see.

One Hacker News user had to explicitly tell the model to stop trying to view screenshots because it kept breaking its own sessions. Another watched it "recreate vision by analyzing pixels" on three separate projects. A third gave it a workaround skill that just silently routed image tasks to a different model, like a manager reassigning work the new hire can't do yet.

That's the backstory to what DeepSeek shipped this week: deepseek-v4-flash-vision-exp, an experimental version of V4 Flash that actually accepts images. The model spent weeks pretending it could see. Now it can. And the story of how we got here says a lot about where agents are headed.

What actually shipped

The boring-but-important part first, because the numbers here are genuinely good.

Vision-Exp is V4 Flash with image input bolted on. Same 1M token context. Same 384K max output. Same OpenAI-compatible API — you swap the model name and send content blocks instead of strings, and your existing code just works. It also speaks the Anthropic API format and the Responses API, which tells you exactly who DeepSeek thinks its customers are: people building agent harnesses.

The pricing is the same as regular Flash. $0.22 per million input tokens off-peak, $0.44 peak. Output is $0.66/$1.32. For reference, frontier models are charging roughly $3–15 per million input tokens. Images get converted to tokens based on their dimensions and billed as input, so a screenshot costs you a fraction of a fraction of a cent.

(One quirk: "peak" is defined as 01:00–04:00 and 06:00–10:00 UTC on weekdays. That's Chinese business hours. If you're coding in California at 9pm, you're paying peak rates because it's Tuesday morning in Beijing. The global model economy is weird like that.)

There's also a concurrency limit of 2,500, which is absurd in a good way. That's not "please contact sales for enterprise rates" territory. That's "pipe your entire agent fleet through it" territory.

The catch: it sees in 1995

Before inference, every image gets resized. Small ones get scaled up to roughly 384×384. Big ones get scaled down to roughly 800×800 — about 0.64 megapixels, which, as one HN commenter gleefully pointed out, is less resolution than a Super VGA monitor from 1995.

This is the real limitation, and it's worth being honest about it. At 800×800, the model can see your UI screenshot, your chart, your photo of a broken pipe fitting. It cannot reliably read small text on a full-page document, parse a dense schematic, or pick out fine detail in a high-res photo. One commenter put it bluntly: full A4 pages of OCR are out.

But here's the thing — the people actually building with it didn't shrug and walk away. The thread immediately filled with workarounds, and they're all variants of the same idea: give the model a zoom tool. Let it request a crop of specific coordinates. Tile the image into a grid, process each cell, then stitch the results together in a final pass. One person pointed out that the newest agentic models already do some of this unprompted — they'll notice they can't read something, call ImageMagick or PIL to crop a subimage, and look again.

If that sounds familiar, it should. It's exactly what you do when you squint at a menu in a dim restaurant. The vision is low-res; the behavior around it is high-res. For an agent, that turns out to matter more.

Why vision is load-bearing for agents

Here's my actual take on why this release is more interesting than a spec sheet suggests.

For a chatbot, vision is a demo feature. Show it a meme, ask what's in the picture, everyone claps. But for an agent — something that takes actions, runs code, clicks things — vision is the difference between guessing and checking.

The single most common pattern in the HN thread, across dozens of unrelated use cases, was closing the loop. You're a frontend dev: the model writes the component, spins up the dev server, screenshots the result, sees the misaligned button, fixes it. You work with matplotlib plots: the model renders the figure, actually looks at it, catches the overlapping axis labels. Someone's running a 3D printer with cameras pointed at it — the model watches prints fail and cancels them autonomously. Another user has research agents attributing methane plumes in satellite imagery to specific oil and gas facilities. One person is building an agentic graphic design tool where the model critiques its own compositions.

Different domains, same structure: act, look, correct. Without vision, the model writes code and hopes. With vision, it writes code and knows. Several commenters said almost exactly this — "it closes the development loop" — and one summed up the pre-vision experience as the model constantly reminding them "you have to validate this manually." The model knew it was flying blind. It told you so.

Which loops back to those hallucinated-vision anecdotes from the top of this post. V4 Flash wasn't hallucinating eyes because it's broken. It was hallucinating eyes because its training taught it that of course a competent assistant can look at a screenshot — and the gap between what it believed it could do and what it could do kept surfacing at the worst possible moment. The model's self-model outran its body. Vision-Exp is the body catching up.

The open-weights question

DeepSeek hasn't said when — or definitively whether — Vision-Exp weights will drop. But the HN thread's answer was basically "give it a few days," and that's backed by history: DeepSeek has open-sourced every major release, sometimes within hours, sometimes after a short wait. Their whole trajectory — V3, R1, V4 Flash on people's Macs — is the reason "open weights" and "frontier-adjacent" stopped being contradictory.

If the weights do drop, this gets interesting fast. A cheap, agentic, vision-capable model you can run on your own hardware is the exact missing piece for local automation stacks. Right now, the people self-hosting Flash are stitching vision on with duct tape — routing image calls to Kimi K2.6 on Cloudflare, running PaddleOCR-VL as an MCP server, mixing GLM into the pipeline. Clever, but it's three models pretending to be one. A single model that can reason and look, at Flash prices or on your own GPU, collapses that whole category of plumbing into a config change.

And there's a competitive wrinkle: the resolution cap is an obvious gap for someone to attack. Gemini's flash-tier models already offer a high-resolution option for screenshots. If open-weights vision at 800×800 proves the demand, someone — Qwen, GLM, or DeepSeek's own GA release — ships the 1080p version. The watershed, as one commenter put it, is around triple today's resolution. That's not a research problem. That's a cost decision.

What to actually do with this

If you're building anything agentic, three practical takeaways from this week:

Wire up the screenshot loop if you haven't. The pattern is: model acts → capture the result (screenshot, rendered image, camera frame) → feed it back → let the model self-correct. This single loop does more for output quality than most prompt engineering. People running it report models catching their own visual bugs that text-only models ship with a shrug.

Give it a zoom tool. Whatever harness you're using, expose a "crop this region" function. Low-res base vision plus a zoom tool beats high-res vision without one, because the model can decide where to look harder. This is also just… how attention works in humans. Cheap trick, big returns.

Don't route everything through vision. The smart architectures this week look like: cheap fast text model for 95% of the work, vision on demand for verification moments. One user described exactly this — Flash as the daily driver, image calls kicked out to a vision model only when needed. Vision-Exp makes that a single-vendor, single-API setup instead of a multi-provider Jenga tower.

The meta-pattern across all three: the model's senses are now cheap enough to treat as tools rather than features. That's the quiet shift this release represents. Vision stopped being a premium add-on and became a line item at flash prices.

The part where I tie this to a product, gently

We build CopperRiver, a desktop AI assistant that browses websites, runs terminal commands, reads your files, and automates the boring parts of your day — running on open-source models like DeepSeek, GLM, Qwen, and Kimi. If you've read this far, you've probably already connected the dots: an assistant that drives a browser and a terminal is exactly the kind of agent that's been flying blind this whole time. Eyes on the work is the whole game.

If you want to poke at it, it's at agent22.app/copperriver. Plans start at $9/mo, which — if you do the token math above — is roughly what you'd pay DeepSeek for a few very productive days anyway.

Meanwhile, somewhere in a data center, a model that spent a month faking vision just opened its eyes. First thing it will probably do is screenshot its own UI and check whether the buttons line up. Honestly? Good instinct.