The $0.14 Model

Same checkpoint, different question, very different answer.

Terminal-Bench asks whether an agent can finish a task in a terminal — tools, files, commands, iterate until it works. DeepSeek is genuinely excellent at that.

AA-LCR asks something else: can the model reason across a long context, not just retrieve a fact from it. On that evaluation the same 0731 checkpoint scores 66%. It improved — up three points from the previous Flash — but it is not near the top.

That gap is the whole point. A 1M-token context window tells you how much text fits. It does not promise the model will hold every dependency across that text equally well. Those are separate capabilities, measured by separate benchmarks, and only one of them made it into the screenshots.

An agent upgrade, not a bigger model.

DeepSeek describes 0731 as an agent-capability upgrade to the existing V4 Flash architecture. Same size — 284B total parameters, 13B active — same 1M context, same price. What changed is behaviour:

That Codex line is the part with practical consequences: it means you can point an existing Codex setup at this model without rebuilding your harness.

Artificial Analysis put the new checkpoint at 50 on their Intelligence Index, up from 40 for the April Flash. That places it level with Gemini 3.6 Flash, one point behind GPT-5.6 Luna and GLM-5.2, and seven behind the open-weights leader Kimi K3.

Two numbers from that run deserve more attention than the headline. Output token use fell about 12% — roughly 206M tokens to run the index against 234M before — so it got smarter while talking less. And the hallucination rate dropped 12 points to 84%, which is where the Omniscience gain came from: it is not more accurate, it just declines to guess as often.

The number that made everyone pay attention was not a benchmark.

Benchmarks moved the conversation, but this is the post that moved people to actually try it — one prompt, a full agent run, and a bill you have to read twice.

Seven cents. His framing — "this model is so cheap to the point where 2 dollars can last you a full day" — is the honest version of the excitement, and at these rates it is arithmetically fair. Cheap enough changes what you are willing to attempt: parallel candidates, throwaway experiments, agent loops you would never have run at $50 per million output tokens.

Then somebody ran the controlled version, and the gap showed up.

The single-model demo tells you it works. It cannot tell you what you gave up. For that you need the same prompt against comparable models, scored the same way — which is exactly what Command Code ran.

The scoreboard is the most useful thing published about this model all week — quality on the left, what it cost on the right:

Their conclusion — "~150x cheaper, but rough around edges" — is the sentence to keep. DeepSeek did not fail. It produced a working result for a twentieth of a cent while the polished builds cost roughly a hundred and fifty times more. Whether 7/10 at $0.0005 beats 9.5/10 at $0.0740 depends entirely on whether anyone has to look at the output.

That is the decision, stated plainly: if a human reviews it, buy the polish. If a test reviews it, buy the price.

Token price is not task price.

Here is the run that complicates the seven-cent story. Same model, turned all the way up, on a genuinely hard one-shot build.

Fifty million tokens. At $0.28 per million output that is real money, and more importantly it is ten hours of wall time for one attempt. His verdict — "weirdest Spiderman I've ever seen", needing extra sequence prompts to stop the camera spinning — is the part that matters: the spend did not buy a finished result.

This is the trap in every cheap-model comparison. A low per-token rate becomes expensive when the model needs more turns, longer outputs, or repeated retries to reach the same place. Measure the finished job, not the row on the pricing page:

1. Use your real production prompt. Toy prompts hide the failure modes that cause retries, and retries are where the price advantage goes.
2. Record total input, output, cache hits, retries, and wall time. Not just the per-token rate.
3. Score the finished artifact. A successful API response is not a successful task.
4. Run it more than once. One lucky or unlucky result is not a routing policy.

The API price is not even the real story. The weights are.

Everything above is about renting the model by the token. But this is an open-weights release, and quantised builds landed within a day — which means the per-token price stops being the ceiling on what it costs you.

168GB of RAM is not a laptop, but it is not a datacentre either — and the 3-bit build at 110GB brings it inside reach of hardware people actually own.

Treat "unlimited super intelligence" as enthusiasm rather than a spec — a 3-bit quant is not the full-precision model, and the AA-LCR gap above does not close because you moved the weights to your own box. What is genuinely true is the shape of the trade: a fixed hardware cost replaces a per-token bill, and for a workload you run constantly that arithmetic can flip fast.

That is a prediction, not a measurement, and it belongs in the same bucket as every other confident forecast about this industry. But the direction is hard to argue with when a model that beats Fable 5 on one agentic benchmark ships weights you can download the same week.

Test the context curve, not the maximum window.

The gap between the two charts is a long-context reasoning gap, so measure that directly. The sweep below runs one reasoning task at three context lengths against two models, with a fixed answer key. Five facts are scattered through each generated document and every question requires combining several of them — which avoids the usual needle-in-a-haystack mistake of measuring retrieval when you meant to measure reasoning.

The dry run spends nothing and prints exactly what it would call:

cd content/08-deepseek-v4-flash-interactive/experiments
./context-sweep.sh --dry-run

When you are ready to spend, build the documents first, then run the paid sweep:

./context-sweep.sh --build-only
./context-sweep.sh

Read individual answers, not just the aggregate score. Treat API failures as a separate column from wrong answers — they are a different problem with a different fix. And repeat the sweep before you conclude anything, because a single pass at one context length is noise.

How to decide, in one pass.

Bottom line: DeepSeek V4 Flash 0731 is a genuinely strong low-cost agent engine, and the Terminal-Bench result is real. Buy the price advantage where the task is verifiable and the prefix is cacheable. Do not turn one benchmark into a universal claim — the second chart exists.

Three routes into a real agent, none of them longer than a coffee.

Everything above is an argument about where this model belongs. Here is how you put it in front of your own work, so the argument stops being theoretical. All three routes end at the same place: a terminal agent that edits your files, running on a $0.14 model.

OpenCode — the fastest route

The model is already listed in OpenCode — 1M context, $0.14 in, $0.28 out, weights linked from the same page. So the whole setup is one command and an API key from the DeepSeek console:

opencode
/connect          # search for DeepSeek, paste your API key
/models           # pick the DeepSeek entry, start working

If you want to pin the exact checkpoint rather than whatever the provider list defaults to, declare it yourself in opencode.json. Any OpenAI-compatible endpoint works through the same block:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "deepseek": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "DeepSeek",
      "options": { "baseURL": "https://api.deepseek.com/v1" },
      "models": {
        "deepseek-v4-flash": { "name": "DeepSeek V4 Flash 0731" }
      }
    }
  }
}

Codex — official, and it needs the Responses API

The 0731 checkpoint natively speaks the Responses API format, which is the part that makes it drop into Codex rather than merely talk to it. There is an official setup script in DeepSeek's docs, or you can edit ~/.codex/config.toml yourself:

model = "deepseek-v4-flash"
model_provider = "deepseek"

[model_providers.deepseek]
base_url = "https://api.deepseek.com/"
wire_api = "responses"
experimental_bearer_token = "<your DeepSeek API key>"

Note wire_api = "responses" — set this to chat completions and you lose the agent behaviour that the Terminal-Bench number was measuring.

Local weights — same config, different URL

This is where the weights section stops being a talking point. Serve a quantised build with llama.cpp, which exposes an OpenAI-compatible endpoint:

llama-server -m DeepSeek-V4-Flash-0731-Q4_K_M.gguf --host 0.0.0.0 --port 8080

Then point the same opencode.json block at http://localhost:8080/v1 instead of the DeepSeek API. The agent cannot tell the difference; your bill can. Nothing leaves your machine and the per-token cost goes to zero — you have swapped it for RAM and electricity.

One reasoning task. Three context lengths. Two models. Scored against an answer key.

Cost: about $1.50 at the prices written at the top of context-sweep.sh. Almost all of it is Claude's 200k-token call. DeepSeek's three calls come to roughly four cents. --dry-run prints the estimate and calls nothing.

Why it's built this way

AA-LCR measures long-context reasoning, not retrieval. So this test scatters five facts through a long document and asks three questions, each of which needs two or three facts combined. Nothing can be answered by finding one line.

That distinction is load-bearing. A needle-in-a-haystack test — "what's the magic word on line 40,000" — is a retrieval test, every decent model passes it, and it would flatter both models into a flat line. It would also be measuring the wrong thing, which is the exact mistake this video is about.

Haystacks are generated from a fixed seed, so re-running is a real re-run and not a new experiment.

The five steps

1 · Look at the plan (free)

cd youtube-videos/06-deepseek-v4-flash-the-other-chart/experiments
./context-sweep.sh --dry-run

Builds the haystacks, prints the six calls it would make and a cost estimate. Nothing is called and nothing is spent. Read the estimate before you go further.

2 · Read one haystack yourself

./context-sweep.sh --build-only
head -40 haystacks/hay-4000.txt
tail -12 haystacks/hay-4000.txt
cat haystacks/key-4000.json

3 · Set the two keys and run

export DEEPSEEK_API_KEY=...      # never commit these
export ANTHROPIC_API_KEY=...
./context-sweep.sh

Six calls, a few minutes, ~$1.50. Prints the score-vs-context table and the real cost per cell.

4 · Read the detail before you believe the score

cat out/deepseek-v4-flash-200000/score.json | jq '.detail'

This is not optional. The grader is lenient about form and strict about content, but it is still a regex. Two failure modes to check for by eye:

• A right answer in the wrong format scores zero. The prompt does demand a strict format, so instruction-following is legitimately part of the test — but you should know that's what happened rather than report it as a reasoning failure.

5 · Run it a second time

It's cheap enough. "Two runs" is a materially stronger sentence than "one run" for about a dollar fifty, and if the two runs disagree, that's the most interesting thing you'll find all week and it goes straight in the video.

Then type the numbers into slide 17 of ../slides-youtube.html — it ships with — placeholders and an empty plot. Replace every one.

Rules

• out/ and haystacks/ are gitignored. Don't commit run artefacts.

Files

What was tested before this shipped

Against a stubbed curl, so no real spend:

• ✅ Both provider response shapes parsed (Anthropic content[], OpenAI-compatible choices[])
• ✅ Cost arithmetic checked against known token counts
• ✅ API failure → FAIL, never a silent 0%; error kept in out/*/error.txt
• ✅ Missing/empty answer file handled
• ✅ Grading: terse-correct, verbose-correct, alternate phrasing, wrong content, partial, and the case where an answer says "none" and names a depot (must fail)
• ✅ Same seed → byte-identical haystack; different seed → different haystack
• ✅ --report replays a finished run without calling anything
• ✅ bash -n clean, and no bash-4-only syntax