Yuval Avidani
Author
On October 17th, DeepSeek released DeepSeek-V4.1-Flash-1017, a model with open weights under the MIT license, and on the same day lit up Search and Fetch APIs that work for free from DeepSeek Harness, from Claude Code, and from Codex. Three pieces, one announcement, and a simple bottom line: a high-level coding agent costs less today than ever before.
On Hacker News, you could feel it. The thread about the model itself climbed to around 943 points and more than 700 comments, and ten days earlier, a blog post by a developer named Jono, titled "Why isn't the industry freaking out about DeepSeek 4.1 Flash?", hit 1,139 points and almost 1,000 comments. Let's break down exactly what came out, what it means for us as builders, and how to try it today.
The situation: a good coding agent costs money, a lot of money
We all know this story by now. A Coding Agent, software that gets a task, reads the code, runs commands and fixes things until it works, burns tokens at a crazy rate. Every file read, every test run, every retry goes into the context window and gets counted on the bill. Think of it like a taxi whose meter keeps running even at a red light: the agent is "thinking" even when it's just reading logs.
Throughout this piece we'll stick with one example: we've got a small Node repo, one test is failing, and we want an agent to find the bug, fix it, and run the tests until everything's green. A completely everyday task, exactly the kind where costs pile up.
On the harness itself, the layer that wraps the model and gives it tools, memory and a work loop, we've already written extensively here in the post What is an Agent Harness, and also in the breakdown of Pi and Oh My Pi. So we won't repeat the basics, just recall the rule: the model is the engine, the harness is the vehicle, and agent quality is a combination of both.
DeepSeek's three pieces
1. The model: DeepSeek-V4.1-Flash-1017. According to the model card on Hugging Face, this is a small update to V4.1-Flash which came out on September 10th. It has 763 billion parameters total, a context window of one million tokens, and the weights are available for download under the MIT license, meaning they can be used commercially too, almost without restrictions. This is an MoE model (Mixture of Experts): according to the config file, it has 384 experts, and for each token only 6 of them are selected plus one shared expert. Think of it like a giant hospital with hundreds of doctors, where every patient only sees a few relevant specialists. In the API, the name deepseek-flash already points to the new version.
2. The harness: DeepSeek Harness, or DSH for short. DeepSeek Harness is an open-source (MIT) coding and work agent built on an architecture where everything is a Plugin, for developers who want control over every layer of the agent. It came out as a developer preview back on August 13th, on October 2nd a desktop app arrived for macOS (Apple Silicon) and Windows, and it's still labeled "Public Preview," with an explicit warning that the core plugins and the API are still changing. Beyond code, the site also shows work with documents, research with source citations, scheduled tasks, and Creator Mode for building plugins. The GitHub repo already has more than 250 thousand stars.
3. The search: Search and Fetch API. Two server-side tools: Search searches the web (on DeepSeek's internal search engine), and Fetch pulls content from a specific page. The official price is $0.75 per 1,000 successful requests, for each of them, and only successful responses with non-empty results get billed. The exciting part is that when using the DeepSeek API from within DSH, Claude Code, or Codex, these search calls are currently free.
And here it's important to be precise, because this gets lost in the threads: the free period is temporary. According to official documentation, per-request billing starts on November 1st, 2026 at midnight Beijing time. It's also important to remember that tokens for the model itself keep getting billed as usual, only the search is free.
The numbers: where it stands against everyone else
Let's look at Terminal-Bench 4.0, a benchmark that tests real terminal tasks, exactly the kind in our example. According to the table DeepSeek published in the model card, the new version jumped from 31.2 to 42.3. For comparison, in the same table GPT-5.6 Sol gets 39.9, GLM-5.3 gets 37.9, and Anthropic's Opus 5 leads with 51.8.
It's important to say this fairly: these are numbers the manufacturer itself published, not an independent measurement. And the picture is more mixed too. On DeepSWE v1.1 the new version gets 77.0, above Opus 5's 74.0, but on ProgramBench and NL2Repo-Bench it's actually Opus 5 that leads (37.0 vs 29.1, and 75.3 vs 68.2). Bottom line: this isn't "the strongest model in the world," it's a model that gets very close to the frontier.
And then comes the price. According to the official pricing page, deepseek-flash costs, during peak hours, $0.30 per million input tokens (when there's no cache hit), $1.20 per million output tokens, and only $0.006 per million input tokens that are already in cache (Cache, "intermediate memory" that saves reprocessing the same text). Outside peak hours, all prices drop by half. Peak hours are 01:00-04:00 and 06:00-10:00 UTC on weekdays, which is roughly 03:00-06:00 and 08:00-12:00 Israel time in winter.
In our example, let's say the bug-fix session read a million new input tokens and wrote 100 thousand output tokens. During peak hours that comes out to 0.30 plus 0.12, meaning 42 cents. At night, 21 cents. And that's before the cache knocks most of the repeated input down to almost zero. This is exactly the argument from the post that sparked the HN discussion: the author claims his sessions almost never go over a dollar. That's his personal experience, not a measurement, but the math above shows it's not far-fetched.
Trying it ourselves: two ways to fix the bug
The first way: DSH directly. The official site and repo show one command that spins up a local Web interface:
In short, for anyone reading without the widgets: you run npx @deepseek-ai/dsh web, the interface comes up by default at http://127.0.0.1:3080, you connect your DeepSeek API key, open the repo folder, and ask the agent to find why the test is failing and fix it. For anyone who prefers an app, there's a desktop download on the site. And for anyone who wants to build from source: git clone the repo, then pnpm install, pnpm run build, and pnpm dsh web.
The second way: Claude Code with DeepSeek's engine. Turns out DeepSeek offers an API compatible with Anthropic's format, and its official docs have a full guide for connecting Claude Code. You change a few environment variables, and the whole Claude Code harness, with the tools and permissions we already know, runs on DeepSeek's model:
In practice, you set ANTHROPIC_BASE_URL to the address https://api.deepseek.com/anthropic, put your DeepSeek API key in ANTHROPIC_AUTH_TOKEN, and point all the models to deepseek-flash. Notice one detail from the docs: if Claude Code requests a model starting with claude-opus, it gets mapped to the more expensive deepseek-v4-pro, which is why the guide explicitly also sets ANTHROPIC_DEFAULT_OPUS_MODEL. The docs also warn that web search from within Claude Code generates additional API requests, meaning more tokens, and starting November 1st, billing on the search itself too.
A fair comparison: DSH, Claude Code, and Codex
The real question isn't "which agent is best," but which combination of harness and model fits us. Each one is a different approach:
DSH is the "everything's open" approach: open source under MIT, everything's a plugin, and a model with open weights behind it. The price of that freedom is maturity: it's still a preview, and heavy users have already posted complaints on HN threads that swapping out a core plugin isn't the same as fine-tuning one. Claude Code is the approach of a polished harness built around Anthropic's models, whose Opus 5 leads on most rows in DeepSeek's own table, while being flexible enough to run on a different engine too. OpenAI's Codex is the third approach, built around OpenAI's models, and DeepSeek explicitly names it as one of the tools where its search is currently free.
And what about running locally? "Open weights" sounds like "I can run this at home," but 763 billion parameters is way beyond any home computer, even with the experts stored in tight precision. The model card points to running it with vLLM or SGLang, meaning servers with multiple GPUs. Open weights matter mainly for companies: you can run the model on your own cloud, without the code ever leaving, and nobody can cut off your tap.
My take: why the industry isn't "freaking out"
In my view, the answer to the HN question is simpler than it looks. The industry is paying attention, but it knows two things. First, the benchmarks in the table are DeepSeek's own, and until we see independent measurements on real tasks, caution is warranted. Second, in real work, the difference between 42 and 52 on Terminal-Bench is sometimes the difference between an agent that finishes the task and one that gets stuck halfway, and when you're under pressure on a production bug, you're willing to pay for that.
On the other hand, what DeepSeek did here is very smart. It's not just releasing a model, it's building a whole system: an open model, an open harness, and a search infrastructure that also plugs into competitors' harnesses. And there are caveats worth remembering: DSH is still in preview, the free search ends November 1st, and there are data policy questions every organization needs to check before sending code to a Chinese company's API. That said, the open license solves exactly that for anyone willing to run the model themselves.
My recommendation: take our example, a small repo with a failing test, and run the same task in regular Claude Code, in Claude Code with deepseek-flash, and in DSH. Check how long it took, how much it cost, and whether the fix is actually correct. After three runs like that, every one of us will know more than any benchmark table.
Want to take this further?
The day-to-day work with coding agents, how to connect models, manage context, and keep costs under control, I break down in depth in the Claude Code Mastery course.
And for anyone who wants to understand how to run open models on their own machine, at sizes that actually fit at home, there's the Local LLMs End-to-End course, in Hebrew.
I run these comparisons and post them to YouTube and LinkedIn, and there are short updates on X, on Instagram, and on TikTok. My code lives on GitHub.
So, what about you: would you move your everyday agent to an open model that costs a tenth as much, if it finishes eight out of ten tasks?