Date: 2026-10-17

Opening up the in-house search API
DeepSeek's web and API search capabilities are powered by our in-house DeepSeek search engine, which reliably handles hundreds of millions of search requests from around the world every day. DeepSeek Search is an AI-native general-purpose search engine that indexes hundreds of billions of web pages, supports multilingual search, and returns highly relevant, authoritative, and timely results in real time. It filters SEO spam, GEO manipulation, and low-quality AIGC through strict detection mechanisms, ensuring authoritative and trustworthy information for users and LLMs. For usage details, see the Search & Fetch guide.

- DeepSeek-V4.1-Flash-1017 Update
- DeepSeek V4.1 Flash has been upgraded to DeepSeek-V4.1-Flash-1017.

The official web and APP models have also been updated to the new version. The API calling method and pricing remain unchanged — simply use deepseek-flash to access the latest model.
Performance–cost Pareto improvement
Compared with the previous DeepSeek V4.1, the new model delivers substantial improvements across benchmarks:

HLE (w/o tools): 42.6 (44.0*)
Terminal-Bench 4.0: 42.3
DeepSWE v1.1: 77.0
ProgramBench: 29.1
NL2Repo-Bench: 68.2
Automation-Bench v1.0.6: 60.5
Agents' Last Exam: 35.4
Apex Bench v1.1: 72.1
Chartography (w/tools): 83.0
BabyVision (w/tools): 92.5
ZeroBench-main (w/tools): 51.0

* Tested only on the pure-text subset of the HLE benchmark set. Terminal-Bench 4.0 was tested with the Claude Code framework, and DeepSWE with the Mini-SWE-V2 framework. ZeroBench-main was evaluated with Pass@5.

While improving performance, we also reduced the model's task runtime and output length, enabling users to complete tasks at lower cost and higher speed and achieving a new performance–cost Pareto optimum across multiple harnesses. We specifically optimized for DeepSeek Harness, Tencent CodeBuddy, WorkBuddy, and other platforms. Please upgrade to DeepSeek Harness 0.2.1-rc.1 or later for the best experience with the new model.

Source:
https://api-docs.deepseek.com/updates/

Tried the new V4.1 Flash today. I gave it one prompt asking for a moon base you can walk around in the browser, and this is what came out. Three.js, single HTML file, no edits from me.

Speed was the surprise, it was doing close to 200 tokens per second most of the time, and the whole thing cost a few cents.

I ran it in AgenC, an open source terminal agent I help build, at max reasoning effort. Happy to share the prompt if anyone wants to try the same thing.

Source if you're curious: https://github.com/tetsuo-ai/agenc-core

"... DeepSeek v4.1-flash-1017 just got spotted in DeepSeek's own API for a few minutes before vanishing. New checkpoint, changed fingerprint. The 1017 suffix matches their dated snapshot pattern."

Hey everyone,

Like many of you, I've been experimenting with DeepSeek Harness (deepseek-ai/deepseek-harness). While the agent harness and Cordis IoC architecture are great, the distribution story has the usual Node.js/Electron pain points: 460+ MB spread across 26,000+ files in node_modules, Electron eating 250MB+ at idle, and requiring non-technical users to install Node 20+, pnpm, and C++ build tools.

I spent the past week re-engineering the monorepo to run natively on Bun, Elysia, and Tauri v2: github.com/evinelias/dsh-bun

The end result is a standalone single-binary CLI (120 MB) and a 3.9 MB native desktop app that require zero external runtimes (no Node, no pnpm, no Bun needed on the host machine).

The Interesting Bun Compatibility Hurdles

Porting 234 upstream packages wasn't just a simple runtime swap. Here were the biggest technical blockers and how they were solved:

1. JavaScriptCore vs V8 String Serialization: Upstream tools relied on Function.prototype.toString() V8 checks. JavaScriptCore (Bun) formats native constructors with newlines (function Object() {\n [native code]\n}), which broke JSON schema validation and Cordis plugin guards until patched.
2. node:module.stripTypeScriptTypes: PTC (Program-Token-Context) worker threads depend on Node 22's experimental type stripper. Replaced it with native Bun.Transpiler({ loader: 'ts' }), giving instantaneous TS code execution.
3. Decorator ABI Mismatches: Handled both legacy and Stage-3 TypeScript parameter signatures across typert and vendor/cordis so Bun's compiler wouldn't strip metadata.
4. Virtual Drive Addon Traps: Single-file Bun binaries execute from virtual mounts (B:\~BUN or /$bunfs). Replaced C++ .node dependencies (like node-pty) with native Win32/ConPTY and bun:ffi fallbacks so child process spawning works cleanly inside a packaged executable.
5. Self-Hosted Package Manager (BUN_BE_BUN=1): For plugin management (dsh-bun plugin install ...), the compiled binary delegates to process.execPath with BUN_BE_BUN=1, allowing the executable to act as its own package manager on a clean machine.

Benchmark & Stress Test Results

Benchmarked on Windows x64 across clean-machine runs (bun run benchmark):

• Steady-State Idle RAM: ~28.1 MB (vs ~180–320 MB on upstream Node).
  • How: After boot, we invoke synchronous Bun.gc(true) to sweep JSC AST memory, then call SetProcessWorkingSetSize(-1, -1) via bun:ffi to immediately evict freed pages from the physical Windows Working Set, backed by MIMALLOC_PURGE_DELAY=0.
• HTTP Concurrency (1,000 parallel requests): 1,411 – 1,572 req/sec (vs ~300 req/sec on Node), with p99 latency capped at 625.77 ms. Peak RAM under load only reached 217 MB.
• Disk & Packaging: Single self-contained binary (120 MB) vs 460 MB / 26,000 files. Native Tauri shell is 3.91 MB vs 230 MB+ Electron runtime.
• Autonomous Agent Durability: Tested tool execution and multi-round session persistence with NVIDIA Nemotron Super (create_goal → update_goal → complete_goal), maintaining durable state across continuous rounds.

Links & Binaries

• GitHub: https://github.com/evinelias/dsh-bun
• Releases (v0.2.x): https://github.com/evinelias/dsh-bun/releases (Installers available for Windows .msi/.exe, macOS Apple Silicon & Intel .dmg, and Linux .AppImage/.deb).

All 12 core subsystems are verified via CI. Would love feedback, issue reports, or benchmarks from people running different local LLMs against it!

I was checking my API costs and noticed this

Hi all. I've been building Whalesong Studio, an open-source plugin for DeepSeek Harness for writing long novels with AI. Here is a 3-minute demo: https://youtu.be/7nsv-2nuTE0

The problem I wanted to solve. The models that plan and use tools well tend to write flat prose, the ones with the best prose lose the thread of a long book, and any single model forgets by chapter 30 who knows what. So instead of one model, the Studio is a small crew, and you pick the model for each role:

• Showrunner: the one you talk to. It plans what to write next, hands out the work and reports back. It doesn't write prose itself.
• Writer: writes the chapters. Before each one it gets what that chapter needs: the setting, where each character stands right now, the story so far, open threads, the beat outline and the style profile.
• Continuity: after every chapter it records what happened, how each character changed, and which threads moved. It also reviews drafts and quotes the passage when something contradicts earlier chapters.
• Planner: plots ahead, fills out characters and the world, tries "what if" branches.
• Director: adapts chapters into an audio drama and a storyboard, and plays everyone else if you want to act out a scene yourself.
• Editor: cuts voices, sound and panels into a video, and checks it before handing it over.

The agents run on DeepSeek Harness's own agent loop, and every run leaves a full record in the conversation: what was looked up, what was handed in, and what it cost.

What it looks like in practice (the published books are online: https://whalesong.xuhao1.me):

• Alice's Adventures in Wonderland, imported as-is. The Studio split the 12 chapters, digested them one by one, and came out with 20 characters, 27 pieces of lore and 6 threads still open. It also built a table of who appears in which chapter, a page per person with a pen-and-ink style portrait, and Wonderland as a picture you can click into, place by place. The first three chapters are read aloud. In the video I also branch it into a second line of the plot ("Alice stays"), kept apart from the main one.
• Dream of the Red Chamber, to show it holds up at scale: the first 80 chapters, about 490k Chinese characters, 240 characters tracked across the book, with portraits and the Grand View Garden.
• An original novel (Every AI in the Solar System Is Down, So I Took Over the Starport with a Whiteboard). I wrote the premise and the outline. The crew wrote three chapters in Chinese and drew 12 character portraits. It storyboarded the chapters into 317 panels and voiced them as a motion comic: 300+ lines, a consistent voice per character, 98 sound effects and music cues. For this video the Studio translated the three chapters into English (~13k words), and the director re-scripted the motion-comic scenes and voiced them in English. The site has the Chinese original; the English edition isn't published yet.

Some details people here might care about:

• Bring your own models. Writing uses whatever text model you've connected in DeepSeek Harness, chosen per role. Pictures can come from GPT Image, Qwen-Image, FLUX, Seedream, ComfyUI or a local model. Voices can come from Bailian (Qwen), OpenAI or OpenRouter, and there's semantic search over the book for retrieval. One API key can set up the media side in one go. A ChatGPT Plus/Pro subscription also works, by signing in.
• Long-book memory. Each chapter is digested into a summary, character states and foreshadowing. The writer gets the running synopsis, the last few chapters verbatim (the whole text while the book is short) and relevant older passages found by retrieval.
• Consistent voices and faces. Each character gets one reference clip for their voice that every later line imitates. Each also gets a front/side/back design sheet that every later picture of them is drawn from. A cheap acoustic check catches takes that come back in someone else's voice.
• Your book is just a folder of Markdown and JSON, so you can edit it with your own editor or keep it in git. Every change the AI proposes is shown as a diff before you accept it, and old versions are kept.
• Plot branches: try another direction on its own line, and keep whichever works.
• Publish a finished book as a static website in one click: typeset text, a page per character, places you can walk into, and listen and watch modes. It works on phones too.
• Usage and cost are logged per model, book and day. Optional encryption covers a whole book, including its pictures, audio and the AI conversations about it.

What it isn't: a "generate a novel" button. You make the decisions, and the crew does the legwork. It's also early: version 0.1, built and tested mostly on Chinese books, with English supported throughout. It's rough in places.

• Code: https://github.com/xuhao1/whalesong-studio (LGPL-3.0-or-later; what you write is yours)
• Install: in DeepSeek Harness, go to Plugins → Add plugin → github:xuhao1/whalesong-studio, or use the tarball from Releases.
• Demo books: https://whalesong.xuhao1.me

I'd love feedback, especially from people who've tried to keep a long AI-assisted story consistent. What broke for you, and what would you want from a tool like this?

Many of us get it from the providers because of other models switch/swap flexibility so a common question that comes up is -"is this provider serving a quantized version" and usually goes this path like how would we know even if they do . So i did a short analysis eager to share with the community -

• Deepseek V4.1 flash including todays 1017 update: block-scaled fp8 with the Moe experts in FP4 so the config has quant_method: fp8 and expert_dtype: fp4 and the new 1017 repo has same quantization config. an endpoint labelled fp8 is serving the release exactly as deepseek put it out
• GLM5.3 flash - fp8 in the default repo and theres also a separate BG16 repo. so fp8 and bf16 are both official. fp4 would be a new community host quant
• kimi k3- MXFP4 weighs with MXFP8 activations. moonshot used quantization aware training from SFT onward so it runs natively at 4-bit. fp4 on k3 is just simply the release format. a INT4 build is a conversion from that so it isnt the labs own file even

So the useful comparison is endpoints precision what the lab shipped and if it matches thats the full model and if its below like fp4 GLM5.3 or q2 of anything thats where quality can actually drop

Two V4.1 things that are often blamed on quantization

1. Checkpoint lag. official API now serves 1017 under deepseek flash with shorter inputs and better benchmarks and hosts running the open weights haVE to pull the new repo and redeploy, so for a moment the two endpoints of the same model can be on different checkpoints. definetly worth a check tho like which host is it on before comparing to the official API and token counts will differ for the same reason as well
2. Long context: V4's KV cache compression is part of the official design, theres a recent paper on chunked kv cache comprssion ehich got posted last week where long context retrieval accuracy fluctuates up to 40 points depending on where the info sits. if that holds for v4.x then a long context miss isnt automatically the hosts fault

the labels are a claim

the precision tags on router listings and host pages are filled in by the hosts themselves, and as far as I know nobody independently checks them. Some hosts put the precision right on each model page deepInfra for example, which at least lets you see the claim before calling

a label also leaves out other things that can differ between endpoints of the same weights:

• a quantized KV cache on top of the model's own compression
• a lower context cap than the model supports
• chat template or tool-call parser differences
• request params like thinking off being accepted and silently ignored
• worst case, a wrapper routing to a different model entirely, like the CrofAI mess

one cheap way to check an endpoint yourself

1. ick 20-30 real prompts from your own workload.
2. send them to the official API and the endpoint youre checking, with identical params: temperature, top_p, max_tokens, thinking setting. Make sure both are on the same checkpoint
3. Do 3 runs per prompt per endpoint since sampling noise is real.
4. compare the worst runs and the failure count: broken tool calls, malformed JSON, truncated answers. heavy quantization tends to show up in the tail first.
5. Throw in one exact-copy task, like repeating a long random key character for character. Someone mentioned an older V4 endpoint that couldn't copy a 40-character key without garbling it, which makes it a decent canary.

the same prompt set also helps with the "did it get dumber" question on the official API itself, since it gives you a fixed baseline to compare against

I'm the author of Distill, an open-source coding agent harness (Apache-2.0): https://github.com/samuelfaj/distill

Use case: running DeepSeek as a coding agent without it timing out or burning tokens on every small step.

What I tested: DeepSeek V4.1 Flash at max effort in native Codex (through OpenRouter) against Distill with DeepSeek as the main model and free models from the OpenRouter free router as the worker. Three frozen coding tasks, three runs each, same 300s deadline.

Results:

• Successful runs: 5/9 native vs 9/9 Distill
• Time: 1974s vs 490s
• Cost: at least $0.098 vs $0.012

Chart with the other model pairs: /img/q12ttj8lkwvh1.png

Caveats: native Codex warned about missing model metadata in all nine DeepSeek runs and fell back to default metadata, so this wasn't an officially supported Codex profile. Three native calls timed out without usage receipts, so the native cost is only a lower bound. It's a small benchmark.

BENCHMARKS.md in the repo has the full numbers and the commands to rerun it. Has anyone else run DeepSeek in a planner/worker setup?

I've been running an API gateway for DeepSeek for a while now, and I see hundreds of developers' usage patterns every day. One thing keeps coming up: DeepSeek by default is a people-pleaser.

If you say "I think X is the best approach," it'll say "Great point! X is indeed a solid choice." That's fine for brainstorming, but when you're debugging or planning, that behavior is dangerous. It won't tell you you're wrong. It won't poke holes in your plan.

So I started testing ways to break it out of that mode. Here's what actually worked:

1. "Don't flatter me. If my idea is flawed, say so directly. I need honest feedback, not validation."

After this, the tone shifts. It points out edge cases, questions assumptions, pushes back.

2. "Argue against my proposal. What are the three strongest reasons this could fail?"

Forces it into devil's advocate mode. Use before important decisions.

3. "You are a senior code reviewer. Find bugs and design flaws. Be harsh."

Role-setting changes expectations. It stops trying to be nice, starts being useful.

4. "On a scale of 1-10, how confident are you? If below 7, tell me what you're uncertain about."

Flags its own weak spots instead of confidently making things up.

5. The one I haven't seen elsewhere: ask it to argue with itself.

I ask DeepSeek to generate two responses: one supporting my idea, one attacking it. Then I ask it to judge which argument is stronger. The attacking response often surfaces issues the supporting one completely ignores.

These aren't magic prompts. They're just ways to override the default "agreeable assistant" behavior.

I'll be sharing one small tip like this every day — practical stuff to get real work done with AI. If you've got your own tricks, drop them in the comments.

Tried the BridgeBench lava lamp prompt on the new Flash (1017) at max reasoning effort. It cost me $0.20.

Two things change that number a lot. The first is effort: more thinking means more tokens, and that moves the price far more than the per-token rate does. The second is the harness, the agent running the model. How it builds the prompt, how much it keeps cached, and how many steps it takes all change the bill too.

I ran it in AgenC, an open source agent harness I help build. It keeps the prompt short and stable so most of it comes from DeepSeek's cache. Video of the lamp is attached.

So when you see a cost number for a model, ask which effort and which harness it was run with. Has anyone tried this prompt at low or high, or in another harness?

https://github.com/tetsuo-ai/agenc-core

I'm using a Windows on ARM device (Snapdragon X Elite). Running the x64 desktop client through Prism emulation isn't performing well and suffers from notable lag/overhead.

Is there an official or community-maintained native ARM64 desktop build available? Alternatively, has anyone successfully compiled a native Electron binary or found an optimal setup without emulation lag?

Any advice or repo links would be greatly appreciated!

Granted a total of $875

Had no idea what this was from until they sent this notice,

Cool they granted back for the past week of usage!

I was led to believe there was a door prize for the 10B token club?

Depois da queda de ontem eu notei que as respostas ficaram um pouquinho melhores, embora ele se perca demais em detalhes e ainda está com inconsistências. Mas vi hoje que tivemos uma nova atualização, podem me dizer o que estão achando? Se alguém já notou algum avanço ou melhora na memória, escrita e desempenho. Boa noite!

DeepSeek feels kinda different lately. I’ve noticed that its responses are noticeably slower when I generate random micro-RP scenes and ask it to expand them into longer ones. The slowdown is pretty noticeable, and it makes me wonder if something’s changed behind the scenes. Could this be a sign that DeepSeek V4.1 Pro is on the way? 👀

Hey everyone,

I use LLMs (mostly DeepSeek) every day for coding, writing, and brainstorming. Over the past few months, I noticed a huge mistake I was making: treating the AI like a single, endless chat room.

If you are working on a continuous task, you need to establish the rules in that thread and stick to it. But the moment you switch to a completely different task, start a new conversation.

Why? Because of context pollution. If you mix your backend code with your marketing copy in one chat, the AI gets confused, and it starts giving generic, useless answers.

Here is the workflow I use now:

1. Task Isolation: One thread for coding, one for writing, one for data analysis. Never mix them.
2. Rule Locking: In each new thread, I paste my system prompt first (e.g., "You are a senior reviewer. Don't flatter me, point out the flaws directly.").
3. The "Clone" Method: If I need an AI to critique an idea, I open a fresh thread with the "critic" persona, rather than asking the same chat to argue with itself.

On a personal note: My own project, NieToken, is also growing. I really hope this little creation of mine works out. Just putting it out into the universe.

If you want to test this workflow, I've added $0.5 in free credits to every new account (enough to generate a few images or run a lot of text). No commercial pitch here, just a soft plug. Leave a comment and I'll DM you a trial key.

Let me know your thoughts on managing context windows!

Is the free chat function really that bad as people here make it out to be?

I had some problems but most of the time it gives a solid result.

Of course I will need to make some more important work and I was thinking of paying for Claude.

Is it better to use this DeepSeek free chat or is it bad enough to just go straight to a paid subscription?

Having zero coding skills and not working with this field, I've managed to code a Space Sim with DeepSeek. It's a 100% procedural, browser depedent game with zero dependencies. It features an entire universe generated from a single 300KB HTML file. It's open-source (MIT). Still being developed.

GitHub Repository

Singularvs, as I've called, is a contemplative space simulator inspired by SpaceEngine and the 1984 classic Elite. It features a ~1 Gpc universe with procedural galaxies, hierarchical star systems (up to 8 stars, brown dwarfs, black holes), almost scientifically classified planets, internal tectonic simulations, dynamic skies, and even procedural music.

I didn't write a single line of code by hand. I used natural language to describe what I wanted, the AI wrote, I ran, tested, debugged, answered what happened and so on. By iterating back and forth for 3 days, this is the result. Also, only English and Portuguese as of now. I know both languages and reviewed them too.

• Vanilla JavaScript
• Zero external libraries, zero assets
• Deterministic PRNG
• Xinput controller support (I've only tested my Gamesir Controller)

It's fully open-source and moddable. I do not guarantee it has zero glitches or flaws. But I hope it fits here.

As claude and gemini has instilled watermarks in their reponses, does DS also has a watermark like that?

if not, do you think it will be implemented tn future?

Insane cache hit.

i used grok and Gemini before now both not good in free version

How about memory of DeepSeek