Two sub-dime models landed in the same week, and the temptation is to line them up and crown a winner. Don't. DeepSeek V4-Flash and Qwen3.7 Flash are both absurdly cheap, both carry a 1M-token context, both come from Chinese labs — and they are built for different jobs. Pick DeepSeek V4-Flash if your agent lives in text: code, tool calls, planning, long-horizon reasoning. Pick Qwen3.7 Flash if your agent has to look at something — a screenshot, a PDF, a UI, a video frame — because it is the first vision-language model cheap enough to run in a loop rather than as an occasional treat.

That's the whole decision, and it hinges on one question: does your agent need eyes? DeepSeek V4-Flash has none — it's text-only. Qwen3.7 Flash takes text, image, and video input. So this isn't a smart-vs-cheap tier or a quality cascade. It's a modality split, and the right architecture for a lot of real systems is to run both and route each turn to the model that matches its inputs.

The cheap text workhorse#

DeepSeek V4-Flash is a 284B-total / 13B-active mixture-of-experts model, MIT-licensed with ungated weights, a ~1M-token window, priced around $0.14 / $0.28 per million input/output tokens. The 0731 refresh that shipped July 31 is the interesting part: same architecture, same size, same price — DeepSeek just re-post-trained the weights, and the new checkpoint reportedly beats its own larger V4-Pro-Preview on all nine agent and coding benchmarks the lab published. Terminal-Bench 2.1 went from 72.1 (Pro-Preview) to 82.7 (Flash-0731), within striking distance of frontier closed models; SWE-bench Verified sits around 79%. (All vendor-stated — benchmark on your own harness.) It also picked up native Responses API support and a Codex config path, which is DeepSeek quietly saying use this as an agent backend.

DeepSeek V4-Flash is the cheap workhorse for everything an agent does with text and tools. It just can't see.

If you're already weighing DeepSeek's own two tiers, that's a separate axis — see V4 Pro vs Flash for agents, where the choice is a per-turn cost knob, not a modality one. Here, against Qwen, the DeepSeek pick is the text pick, full stop.

The first cheap pair of eyes#

Qwen3.7 Flash is the other kind of cheap. Alibaba listed it on OpenRouter on July 27 at roughly $0.03 / $0.13 per million tokens — lower sticker than DeepSeek — with a 1M context and, crucially, text + image + video input. It supports switchable thinking, function calling, and prompt caching. What it is not is a coding specialist: Alibaba positions it for visual work — reading mockups, understanding UI screenshots, spatial and real-world scene perception — and points pure-code workloads at Qwen3.7 Max instead. Its weights aren't published; it's a proprietary API-only endpoint, which is the one place DeepSeek's MIT license clearly wins if self-hosting matters to you.

The unlock isn't that vision models exist — it's that vision reasoning is now cheap enough to sit inside a loop that fires hundreds of times per task. That changes what a screen-reading or document agent costs to run. If that's your build, start with the deeper dives: building a cheap screen-reading agent on Qwen3.7 Flash and Qwen3.7 Flash vs Gemini 3.6 Flash for the cheapest vision agent.

Watch the token math#

Qwen's $0.03 input rate looks like it undercuts DeepSeek outright. It doesn't, in practice, because images and video expand into a lot of tokens. A single screenshot can cost hundreds to low-thousands of input tokens once tiled; a few video frames balloon fast. So a vision turn on Qwen can easily cost more in absolute dollars than a text turn on DeepSeek, even at a lower per-token rate. The sticker price tells you the modality is affordable; only your real payloads tell you the per-task bill. This is exactly the kind of thing the per-task unit-economics worksheet is for — measure a real trajectory, don't extrapolate from the rate card.

Many systems want both — route by modality#

Here's the shape most non-trivial agents should land on: keep DeepSeek V4-Flash as the default brain for text, code, and tool calls, and hand off to Qwen3.7 Flash only on turns that actually contain an image or video. This is a modality router, not a quality cascade — you're not escalating hard turns to a smarter model, you're dispatching each turn to the model whose input types it was trained on. Both speak an OpenAI-compatible API and both live on OpenRouter, so the routing logic is trivial:

from openai import OpenAI

client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=KEY)

TEXT_MODEL   = "deepseek/deepseek-v4-flash-0731"  # code, tools, planning
VISION_MODEL = "qwen/qwen3.7-flash"               # screens, docs, video

def has_visual(messages):
    for m in messages:
        content = m.get("content")
        if isinstance(content, list):
            if any(p.get("type") in ("image_url", "input_image", "video_url")
                   for p in content):
                return True
    return False

def run_turn(messages, tools=None):
    model = VISION_MODEL if has_visual(messages) else TEXT_MODEL
    return client.chat.completions.create(
        model=model, messages=messages, tools=tools,
    )

Route by what the turn sees, not by how hard it is. Vision parts → Qwen. Everything else → DeepSeek.

The catch worth testing: multimodal models often trade a little text-reasoning and tool-calling sharpness for their vision skills, and Qwen3.7 Flash is explicitly not the coding-tuned member of its family. So before you let it handle any non-vision turns, run your own tool-calling and coding evals against both. If Qwen holds up on your harness, you could collapse to one model for simplicity. If it doesn't — the likely outcome — the router keeps DeepSeek's agentic edge on text turns and spends Qwen only where eyes are required.

The one-line answer#

No eyes needed → DeepSeek V4-Flash: cheaper reasoning per real turn, open weights, the stronger agentic and coding track record. Eyes needed → Qwen3.7 Flash: the first multimodal model priced to run in a loop. Both → route by modality and let each model do the job it was actually trained for. The mistake is treating them as two answers to one question; they're one answer each to two different questions.