Source: raw/Deepseek_just_did_the_impossible.md (AI Search, “Deepseek just did the impossible”, https://www.youtube.com/watch?v=MImgH4KMtj8, uploaded 2026-09-18, about 31 min; sponsored by Luma) and raw/Deepseek_strikes_again.md (AI Search, “Deepseek strikes again”, https://www.youtube.com/watch?v=1Aqhg0FVm-w, uploaded 2026-10-23, about 27 min; sponsored by Higgsfield). Platform: YouTube auto-captions, fetched 2026-10-30. Caption fixes: “Deep Su 1.1” / “DeepSeek 1.1” → DeepSWE v1.1, “Kimiko 3” → Kimi K3, “GGQFs” → GGUFs, “GPT 5.6 Soul” → Sol, “Cyberjim” → CyberGym.

AI Search’s two DeepSeek videos cover the same model from two sides. The September video explains the V4.1 Flash technical report in plain terms: how DeepSeek cut the per-token KV cache to about 890 bytes and kept decode cost nearly flat out to 1M tokens. The October video tests the V4.1 Flash 1017 update on seven long agentic tasks, reports a total spend of about $6, and covers DeepInfer, DeepSeek’s newly open-sourced inference engine. The benchmark figures in both videos are DeepSeek’s or third-party leaderboards as read by the presenter, not his own measurements. Release dates, pricing and other creators’ tests are in the September landscape and the October landscape.

Key Takeaways

  • It is cheap enough to run long agent jobs without watching the meter. AI Search ran seven tests, some lasting hours (a 375M-token Unreal game build at a 99.5% cache-hit rate), and his 44: about $6 in total.
  • Quality is “80 to 90% there” against the closed frontier on creative builds. His words, comparing against Opus 5.5 and GPT-6 Astra on a 3D game, a DAW music track and a Blender virtual tour. The explainer video and the deep-research report were the strong results.
  • It was the only model in his tests to find the hidden frog, a long-running visual-search test, after cropping, zooming and running colour-channel analysis on its own. On six brain-tumour scans it got all six wrong; he says the best models get about one right.
  • Use it through an agent harness, not the chat page. DeepSeek’s free desktop DeepSeek Harness works like Codex or Claude Code and runs several projects at once. He used it at max effort with full access.
  • The architecture is built for long context on limited hardware (from the technical report, as he explains it): half the layers build the global KV cache and the other half reuse it; layers share and re-index each other’s cache; a gatekeeper layer shortlists about 16,000 of 1M tokens; and short-term memory is recomputed instead of stored.
  • The report’s flagship chart shows decode compute nearly flat from 4K to 1M tokens of context, so a long document costs roughly the same per generated word as a short one.
  • DeepInfer open-sources DeepSeek’s serving engine, with reported figures of 155 trillion tokens per day per cluster, $38 revenue per GPU-hour (an estimated ~80% gross margin) and a 96% input cache-hit rate. It runs on Nvidia and Huawei Ascend chips. The caching and load-balancing layers were not released.
  • Running it locally is not a laptop job. The full weights are about 510 GB; Unsloth’s most compressed 1-bit GGUF is 233 GB.

The 1017 update (October 17)

  • Same architecture as V4.1 Flash: a mixture of experts with 552B backbone parameters and about 16B active when generating.
  • The presenter shows DeepSeek’s chart: a few points better than the previous V4.1 Flash on agentic coding, general knowledge and automation benchmarks, ahead of GLM 5.3 and Kimi K3, and “pretty much on par with GPT 5.6 Sol, which is kind of my experience as well.”
  • DeepSWE v1.1: 77 (DeepSeek’s figure). He notes the official leaderboard “seems dead,” not updated since GPT-6.1 or Opus 5.5.
  • KernelBench (CUDA kernel writing): ranked #3, behind the latest Claude models and ahead of Gemini 4 Argon, Claude Fable and GPT-6 Astra, per the chart he shows.
  • Download from Hugging Face (deepseek-ai/DeepSeek-V4.1-Flash-1017) or ModelScope. The October landscape article records an MIT licence and unchanged pricing.

AI Search’s tests on V4.1 Flash 1017

All runs used the DeepSeek Harness at max effort. These are one creator’s single runs.

TestSetupResult (his assessment)
Motion-graphics explainer (Earth’s circumference)Told to voice it with Gemini TTS, with the TTS docs pasted in36 min, ~22M tokens, 99% cache hits. It chose HyperFrames for the animation on its own. “Even matches what I got from the frontier models.”
Procedural 3D game in Unreal EngineCharacter model from Sketchfab, animations from Mixamo, assets generated through a Blender MCP server, plus a separate “brutal AAA art director” critic agent that scores screenshots and sends issues backRan 16 rounds (he asked for 4); best critic score 5.5/10. Playable, but “about 80% there” against Opus 5.5 and GPT-6 Astra. 375M tokens.
Euro-pop EDM track in his Waveform DAWNot told where the DAW was or how to use itSecond round after feedback (“muddy… add more ear candy”) was “80 to 90% there” against Astra and Opus.
Blender rebuild of an Airbnb property from listing photos, with a camera fly-through1 h 37 minSpatial layout partly right; pillows through sofas, chairs through tables, the pool’s slanted wall missing. “Definitely not as good as the frontier closed models.”
Find the hidden frogAsked only “is there any animal in this image?”Found and circled it. “Even Opus or GPT-6 cannot find the frog.”
Six brain-tumour scansIdentify tumour types0 of 6 correct, in under 2 minutes.
Deep research (amyloid beta and tau in Alzheimer’s)Self-contained HTML report with tables20 min; thorough and correctly cited. He rates it “tied with GPT-6 Astra and much better than Opus 5.5, which is kind of lazy… in terms of medical research.”
Ideation (factory-farm welfare ideas)Three constrained ideas10 min; “climate autopilot,” “forage autopilot” and a third, each with a detailed write-up.

The critic-agent pattern in the game test is reusable on any model: a second agent takes its own screenshots, scores against a written rubric with a pass threshold, and returns a ranked issue list for a capped number of rounds. ^[inferred] It is the same verify-and-iterate shape as verifier-first loops.

How V4.1 Flash is built (the technical report, as AI Search explains it)

The presenter frames the design around two constraints: DeepSeek has less compute and no access to the best Nvidia GPUs, so long-context agent work runs into KV-cache size (fast GPU memory fills and spills to slow SSDs) and the cost of moving that data.

  1. Causal encoder plus decoder. The model’s layers are split in half. During prefill (reading the prompt), the first half reads everything and builds the global KV cache; the second half does nothing. During decode (writing), the second half borrows the finished global cache from the end of the encoder instead of computing its own, and uses sliding-window attention over recent tokens for local context. He says this “slashes the compute required to read things by half.”
  2. Compressed Sparse Attention 2 (CSA2). Layers run in one of three modes: full (builds a new KV cache and an index into it), reindex (reuses a full layer’s cache but builds its own index into it) and reuse (reuses both cache and index). Fewer layers store their own cache.
  3. Hierarchical sparse indexer. The first decoder layer acts as a gatekeeper: from 1M tokens of global cache it shortlists about 16,000 candidates, and later layers may only search that shortlist. DeepSeek trained the shortlist to be accurate enough that later layers “don’t even notice the rest of the info is missing.”
  4. SWA bounded replay. Instead of saving each turn’s short-term (sliding-window) memory to SSD, the model discards it and recomputes the last 128 tokens when needed, because a GPU computes that faster than it can fetch it.
  5. Supporting pieces. Single-pass MHC fuses operations to cut memory traffic inside the GPU. Engram is a 168B-parameter memory module for static facts that lives in ordinary server RAM, not GPU memory. DSpark lets the model emit several tokens at once.

The resulting numbers he cites:

  • Global KV cache per token: about 390,000 bytes for DeepSeek V1, ~3,500 for V4 Flash, ~890 for V4.1 Flash, which is 437 times smaller than V1 and almost four times smaller than V4 Flash.
  • Figure 2 of the report: decode FLOPs stay almost flat as context grows from 4K to 1M tokens, unlike earlier DeepSeek generations.
  • At its September release (per leaderboards he shows): DeepSWE 74.2, “basically on par with GPT-6 Astra, which also scores 74”; top open model on LiveBench; #1 on the Vals index for knowledge work, with second and third place “over 20 times more expensive”; over 200 tokens per second through the API, “like four times faster than GPT-6,” and the lowest time to first token.

These figures are the report’s and leaderboards’, relayed by a creator. The October landscape article gives a different encoder/decoder description from Last Week in AI (40 layers, 20/20, a 3.9x smaller cache than V4 Flash); the two are compatible, and neither source is the paper itself.

DeepInfer (October 2026)

  • What it is: DeepSeek’s inference engine, the software that serves its models across thousands of GPUs and millions of requests. Open-sourced at github.com/deepseek-ai/DeepInfer, usable commercially per the presenter.
  • Figures DeepSeek reported (relayed): one cluster processes 155 trillion tokens per day; $38 revenue per GPU-hour, which he works out to an estimated ~80% gross margin before other expenses; a 96% input cache-hit rate.
  • Hardware: runs on both Nvidia and Huawei Ascend chips, which he reads as a real alternative to Nvidia for anyone constrained by export rules or supply.
  • What is missing: the full caching and load-balancing infrastructure, so “you can’t necessarily replicate its economics just by installing DeepInfer.”
  • Why it matters (his view): frontier labs treat serving optimizations as part of their moat; DeepSeek published them.

Update (2026-11-01): Berman’s tests and the tokens-per-task caveat

Sources: raw/Deepseek_crushed_everyone.md (Matthew Berman, https://www.youtube.com/watch?v=DDZ-a6bAn3Y; sponsored by CoreWeave) and raw/DeepSeek_s_New_AI_Is_An_Absolute_Monster.md (Two Minute Papers, https://www.youtube.com/watch?v=pryCaGv8wuo; sponsored by Lambda). Both cover the 1017 update. Captions write “Deep Suite V1.1” for DeepSWE v1.1 and “Kimmy” for Kimi.

Berman: “the best overall model on the planet” on cost, quality and speed together, “not the highest quality, but close.”

  • Vision. Counting pastries in a photo on max reasoning took 4 minutes 25 seconds: 137 visible items, each named, with an unprompted “defensible range” of 130 to 145 because stacks hide some. Asked to include hidden items, it estimated pile geometry (a macaron pyramid “5 to 6 wide at the base”) and raised the macarons from 24 visible to about 45, in 23 more seconds.
  • Browser and video. Given a YouTube link to his Sam Altman interview, it worked 6 minutes 24 seconds and returned five clippable moments with timestamps he checked as correct, quotes, and a reason for each.
  • Local build. Run locally on his DGX Station (not consumer hardware), it built a working browser spreadsheet (“GridLine”: formulas, fill-down, charts) in 50 minutes. A Rubik’s-cube simulation scrambled and solved correctly.
  • Detailed-prompt build. With a long spec written by Opus 5.5, it built “Folio”, an Electron/React/TypeScript PDF reader with annotation, signatures (drawn, uploaded or photographed), dark mode and printing. He estimates “less than a couple dollars” through a paid host.
  • Weaker spots: a 3D watch model missed the rotor on the back; a Fall Guys clone “isn’t as good as Opus 5.5, but it’s quite close.” He rates it above Kimi K3.1 on his iPhone-model test.
  • Speed and hosting (Artificial Analysis, as he reads it): about 125-150 tokens/s in DeepSeek’s own chat with reasoning off; 1,286 tokens/s from “Lithos AI” (caption spelling) at 0.60 output with cache hits free; Baseten about 845 tokens/s at 1.20 and $0.01 per million cached tokens.
  • Cost per task (AA, pre-v5): **2.11, Astra 5 and Fable 5.1 Max $7.63. Top-left of AA’s cost-quality chart. HLE 42 and Terminal-Bench 42, level with Kimi K3 and GLM 5.3.
  • On AA’s v5 index (late October) it scores 32, level with GLM 5.3 and below Claude Haiku 5.5’s 36 (The AI Daily Brief, in the November landscape).

Two Minute Papers: cheaper per token than per task.

  • API output costs “just a bit more than a dollar per million” tokens, “15 times cheaper than Claude Opus 5.5.” ^[ambiguous: the October landscape and Berman both give $0.60 per million output; the presenter may be quoting a different host or peak pricing]
  • In his own tests it “can easily take two to three times more tokens to accomplish the same thing as Claude Opus”, so “we should always think in cost per task, not per million tokens.” Still good value, “just a bit less good” than advertised.
  • He says the architecture did not change from V4.1 Flash and guesses the gain came from “learning from self-feedback”, the model critiquing and learning from its own work. He says this is his reading of DeepSeek’s announcement, with “no guarantees.”

Try It

  1. Install the DeepSeek Harness (free, desktop) and give it a task you would otherwise give Claude Code or Codex, at max effort. Top up a small balance (20) and check the spend afterwards. AI Search’s seven-test session cost about $6.
  2. Use it for long, cache-heavy runs. His sessions showed 99%+ cache-hit rates, which is where its pricing advantage compounds. Pair it with a frontier model for the final pass on 3D, spatial or design-critical work, where he found it about 80% of the way there.
  3. Copy the critic-agent prompt pattern for any visual output: separate critic, own screenshots, 0–10 rubric, a pass threshold, a ranked issue list, and a round cap.
  4. For self-hosting, budget for the size. 510 GB full weights, 233 GB at 1-bit; that is multi-GPU server territory, not a workstation.
  5. Check data-residency rules before routing client work to DeepSeek’s hosted API; see the Chinese open-weight decision framework.

Implementation

Tool/Service: DeepSeek V4.1 Flash 1017 (open weights), DeepSeek Harness (desktop agent app), DeepSeek API, DeepInfer (inference engine). Setup: Harness: download from DeepSeek, choose the 4.1 Flash model, set effort to max and access to full. Weights: huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash-1017 or ModelScope; quantized GGUFs from Unsloth. Engine: github.com/deepseek-ai/DeepInfer. Cost: API pricing is not given in these videos; the landscape articles record 0.60 per 1M tokens off-peak. AI Search’s full test session cost about $6. Integration notes: DeepSeek cannot generate speech; for narrated videos he gave it Gemini TTS documentation. For Blender work, connect a Blender MCP server and give the agent its address. DeepInfer alone does not reproduce DeepSeek’s serving economics.

Open Questions

  • “Lithos AI” (added 2026-11-01) is a caption spelling of the fastest host on AA’s speed chart; confirm the provider name before using it.
  • Output price (added 2026-11-01): $0.60 per million (Berman, October landscape) or “a bit more than a dollar” (Two Minute Papers)?
  • No independent check of the 1017 benchmark gains (DeepSWE 77, KernelBench #3) appears in either video; they are DeepSeek’s or leaderboard charts read on screen.
  • DeepInfer’s licence is not stated in the transcript. “Use it commercially” is the presenter’s description.
  • The 80% margin is the presenter’s arithmetic from $38 per GPU-hour and assumed hardware costs, not a DeepSeek figure.
  • Engram’s 168B parameters and the 552B backbone: the videos do not say whether the 552B figure includes Engram.
  • What hardware the 233 GB 1-bit build needs to run at usable speed is not given.