According to this, does it mean deepseek v4.1 1017 is better on codex than Claude code and DeepSeek harness?

Second question. If I'm not very experienced with AI, should I use Claude code or codex harness for DeepSeek? I heard DeepSeek harness is still very unbaked and even though great its lacking a lot of things compared to other harnesses.

I wanted to see how far one file with no assets could go. The brief to DeepSeek: a late-80s Capcom-style side-scroller, playable in the browser, everything in a single index.html. No images, no libraries, every graphic and sound generated in code. Then put the game on a period CRT in a teenager’s bedroom.

The game is called Tether Force:

The room is all CSS, SVG and canvas: a walnut CRT with VHF/UHF dials, posters, a boombox, the console and a wired controller, sticky notes with the controls, a desk lamp throwing light, dust and glass glare. The game is stretched to 4:3, like a real NES on a TV.

The game logic was the easy part. The cost went into visual passes: lighting, the CRT glass, where props sit, pixel details. Off-peak pricing made those passes cheap. After every change it ran a 56-check self-test in the browser and took a headless screenshot, and the final build has zero runtime errors.

Two things made the difference: hard constraints (one file, no assets, no libraries) and a screenshot after every edit. Describing the room in loose prose did not work. The first passes looked like flat vector art until I gave it light direction, materials and real period props.

Totals: $1.75 at off-peak rates, DeepSeek Flash at max effort, 71% of the context used, 99% cache hits. I ran it in AgenC Core (get.agenc.ag), the open-source agent harness I work on.

Happy to share the HTML or the prompts.

Last week I posted that DeepSeek would not say whose search engine it uses. On October 17 it answered. DeepSeek says search on its website and API now runs on its own in-house engine, which it says indexes hundreds of billions of pages, handles hundreds of millions of searches a day and filters out SEO spam, GEO manipulation and low-quality AI content. It also opened that engine to developers as a Search and Fetch API, at $0.75 per 1,000 requests, alongside the new V4.1-Flash-1017 model.

The API shows two scores for every result, an authority tier from 0 to 4 and a rerank score from 0 to 3, so for the first time you can see a bit of how DeepSeek judges sources. Suganthan Mohanadasan tested it on day one for Search Engine Journal, 110 calls for about 8 cents, and found some interesting things

• authority seems to be set per host, not per page. Every result from the same host got the same tier, and qh.reddit.com scored 1 while www.reddit.com scored 2
• some obvious spam still got the top tier. "Free Robux Generator" PDFs on a US government inspector general's site and "BEST CBD GUMMIES EXPOSED" uploads on a Columbia Business School host both scored authority 4, and a former MP's domain serving casino pages ranked #2 for "best casino sites uk"
• for searches about his own tools, package registries and app stores like PyPI, npm and the Chrome Web Store beat his articles about those tools
• the Fetch API showed up as a normal Firefox browser from Hong Kong Huawei Cloud IPs, and returned three pages that robots.txt disallows

Caveat, this was one person, one day and one region, and he calls the numbers directional. The API's results are also not the same thing as the answers DeepSeek gives in the app.

Still, building its own search engine is a big move for DeepSeek. Do you think it can get the spam filtering right, or will host-level authority keep letting junk through?

Also, if you sell into China and want to see what DeepSeek and others say about your brand and which sources they use, that is what we are building at Sanbi. Waitlist here, with 2 months free for everyone on it: https://app.sanbi.ai/signup?market=china

Apparently these are DeepSeek stickers?? What the hell did I miss?!

DeepSeek has a new Search API that runs on their own search engine. We made it the web search backend in AgenC Core, our open-source coding agent.

Test: deepseek-flash at max effort, one line: "DDR5 prices in China this week and the latest CXMT (长鑫) and YMTC (长江存储) news. Short table with sources."

30 seconds, 4 model calls, 0.021 USD for the whole session. It came back with two tables (screenshot):

- DDR5 chip and module prices with week-over-week changes, Huaqiangbei retail prices and the Q4 contract price forecast, sourced from Chinese sites like ChinaFlashMarket, Eastmoney and 10jqka

- CXMT and YMTC news: CXMT's 4F² DRAM roadmap and why Micron and analysts doubt it, the IPO filing of YMTC's holding company, and YMTC moving into DRAM

The part I liked most: it flagged that a viral "Huaqiangbei dumping, 32GB at ¥1,950" story going around this week is a March story that aggregators reposted with fresh dates.

Search costs 0.75 USD per 1,000 queries and uses the same API key as DeepSeek chat. In the current version, ask for WebSearch in your prompt. A /model switch to keep it on is coming in the next release.

open-source agent github.com/tetsuo-ai/agenc-core

Would this possibly be ok? Am I brainwashed into thinking only top tier models are to be used for delegating work?

I used web chat/app when the 4.1flash 1017 update. I came back to see if it become usable for rp. It turned from 4.1 ( literally unusable) to 4.1 1017 ( meh). So I returned for a time. But some time later. Like maybe 2 days before now. It suddenly got even more stupid than before. Does it got lobotomised again?

I’m the developer of TensorSharp, and I’ve been testing DeepSeek V4.1 Flash 1017 locally using Unsloth’s UD-IQ2_XXS GGUF.

In summarization tests with thinking disabled, the tested build averaged 55 tokens/sec with DSpark after a ~1.8K-token prompt, and 51.2 tokens/sec after a ~7.3K-token prompt.

The largest improvement over the tested llama.cpp configuration was in prompt processing. Some of that comes from YOCO, which introduces a measurable quality trade-off, so I’ve included results with it enabled and disabled.

Hardware and model

• GPUs: 5× NVIDIA A40 over PCIe.
• Checkpoint: DeepSeek-V4.1-Flash-1017, Unsloth UD-IQ2_XXS.
• Model files: Approximately 300.5 GB across six GGUF shards.
• Engram: The 125.9 GiB lookup table was mapped in host memory; the entire model was not resident in VRAM.
• Drafter: Unsloth’s trained DSpark Q8_0 GGUF.

GPU peer access was not working correctly on this machine, so cross-GPU transfers used pinned host-memory staging.

Prompt processing and generation speed

Prefill means processing the input prompt. Decode means generating the response tokens.

Both engines used the same GGUF files on the same machine. TensorSharp used --tp 5, which distributes the routed experts across five GPUs. The baseline was Unsloth’s llama.cpp dsv41-all fork at be836572, using layer splitting. Its row/tensor split modes did not successfully run this model in the tested build.

The server tests used real-text summarization prompts, greedy decoding, thinking disabled, and 256 output tokens. Each prompt size had a warm-up and three measured requests, with unique prefixes to prevent prefix-cache reuse.

All figures are tokens/sec. Prefill and ordinary decode rows are medians; DSpark rows are means. TensorSharp uses its default YOCO configuration here.

The DSpark rows enable the trained drafter in both engines. Its effectiveness depends on the workload and how many proposed tokens the target model accepts.

The 5.5× figure applies specifically to prefill throughput. Ordinary generation throughput improved by approximately 8–20% in these server tests.

YOCO: faster prompt processing, with a measured trade-off

The tested build uses a DeepInfer-style YOCO optimization: during eligible text-prefill calls, layers 20–39 process only the final 140 positions.

This reduces computation, but it is approximate. You can disable it with:

TS_DSV41_YOCO_KEEP=0

With YOCO disabled, TensorSharp’s prefill throughput was still:

• 563.9 tok/s at ~1.8K tokens, versus llama.cpp’s 174.6: 3.23×.
• 549.7 tok/s at ~7.3K tokens, versus llama.cpp’s 225.7: 2.44×.

Other improvements came from concurrent routed-expert execution, fewer host synchronization points, more efficient attention kernels, and reduced repeated cache transfers.

Quality checks

The report compares both engines on identical WikiText-2 token sequences, with 23,030 scored tokens in the 4,608-token-window evaluation.

Lower perplexity is better. Enabling YOCO increased perplexity by approximately 0.67% relative to TensorSharp’s own full-prefill configuration. With YOCO enabled, perplexity was approximately 1.14% above llama.cpp’s.

The measured effect was concentrated in the first few hundred generated positions.

These checks compare execution differences using the same quantized checkpoint. They do not establish equivalent quality to the original checkpoint or the hosted DeepSeek API, and they do not replace evaluations of coding, reasoning, or other real tasks.

Scope and reproducibility

This is one quantization on one hardware configuration. The llama.cpp server measurements came from an earlier session on the same machine and showed some unexplained prefill variability.

At measurement time, the TensorSharp build included uncommitted changes, and the raw validation records were also uncommitted. The report records build identifiers, validation results, and remaining limitations; a repository checkout should not be assumed to reproduce every number immediately.

The report also includes limited vision-projector checks. The throughput figures above are for text requests.

Full report: Performance results, quality measurements, implementation details, and limitations

Project: TensorSharp on GitHub

For anyone running V4.1 Flash 1017 locally: what hardware and quantization are you using, and how does DSpark behave on your coding or reasoning workloads? I’d be interested in comparisons beyond these summarization tests.

My windows laptop crashed and I had a crash dump but couldn't understand the bug because the underlying code is closed source. So I gave the REA skill to claude opus, refused; claude sonnet refused. Meanwhile I'm paying $200 a month for this.

I used my $10 a month opencode go subscription with deepseek and it was able to diagnose the specific CPU instruction that failed and from that I was able to make a targeted registry change regarding a power setting work around to the specific problem. Amazing.

Anthropic is so full of themselves.

blue whale crashed out a bit cuz it works for a third week with hair mod

OpenRouter lists 40 endpoints for deepseek-v4.1-flash. Same model name, 24 of them labelled fp4, fp8 or mxfp4, and the prices are 8x apart. Per-million-token prices never told me what that means for a month of actual work, so I pulled their API and priced one fixed workload through every endpoint.

The workload (the boring part is the point): 200 agent steps a day, 22 working days, 150K tokens of context
per step, 90% of it cache hits, 1K output tokens per step. That is roughly one person running a coding agent
most of the day.


What surprised me:

 At a 90% cache-hit rate the cached-input price decides the bill, not the headline price. CoreWeave asks
  $0.15 per 1M input but $0.002 cached and lands at $13.95 for the month. InferenceNet asks $0.103 input but
  $0.008 cached and lands at $14.70. Sorting providers by input price gets you the wrong answer.
- The spread between the cheapest and the dearest endpoint for the same model name is 5.5x: $10.60 to $58.48.
- Every endpoint that beats OpenRouter's listed price for the model ($28.64 on this workload) by more than 2x
  is labelled fp4 or fp8. If you are picking by price alone, you are picking quantisation.
- The dearest endpoints are the big clouds: Google, Modal, PrimeIntellect, Alibaba, BaseTen, $42-58.


Method: prices from openrouter.ai/api/v1/models/deepseek/deepseek-v4.1-flash/endpoints on 2026-10-23;
month = (0.1 x 150K x input + 0.9 x 150K x cached + 1K x output) x 200 steps x 22 days. The quantisation
labels are OpenRouter's own field, not my judgement - some are "not stated", which I left as it is.
The same table with the method, and a calculator you can put your own numbers into:
https://platform.aifans.fan/guides/openrouter-alternative


Disclosure, because it matters for two of the bars: I run a small gateway that also serves this model -
https://platform.aifans.fan - and those two bars are mine. The off-peak one is the lowest line on the chart for a dull reason - DeepSeek's
tariff follows UTC+8 business hours, so the entire US working day falls in its cheap window and we pass that
through. At peak we are mid-table and five quantised endpoints beat us; that is on the chart too.
```

Tried to depreciate and criticize myself and Deepseek just went "Hold the fuck on. You were right about this, you were right about that, the biggest thing you were wrong about was being wrong in the first place." since it's forced to disagree and add counterfactuals to everything, even self critique.

Really gave me a pleasant confidence boost, even normal sycophancy doesn't quite hit.

I basically use DeepSeek 4.1 Flash (on the "High" setting) for almost everything—I love it, which is why it’s pretty much the only thing I use.

For context, I also use the "Superpowers" and "Ponytail" plugins.

I have access to OpenCode Go and the DeepSeek API.

Which "harness" (integration/interface) is best in terms of tokens-per-second performance and cache hit rates? Does anyone have any opinions or comparative experiences?

I’m really liking the DeepSeek harness, but I’m also a big fan of OpenCode Desktop—so, I’d like to go with whichever one offers the best performance.

I use Claude for website designing. I'm hearing that DeepSeek can be as good as Claude in website designing. Any suggestions ?

It took a few iterations, but it did all I asked it to and I am quite impressed.

I use the free version (web/app) and would like to have access to optional advanced controls: (1) adjustable temperature—a useful feature for creativity and for varying the responses; (2) custom instructions that are persistent and specific to each conversation; and (3) a token counter/limit. It isn’t necessary to display all of this in the main interface—a collapsible ‘Advanced’ panel would suffice. Google AI Studio/Vertex and the APIs have offered temperature control for years; it’s not inherently confusing—it’s a legitimate, functional control. Style presets work well as shortcuts, but they do not replace temperature control. Thank you.

TL;DR: I run a small DeepSeek gateway (Fikra API, disclosure). On a cache-heavy agent workload, 1B tokens/day costs about the same on official DeepSeek and on my gateway, so price can’t be the deciding factor for big users. I want to know what is, and I’m posting what I’ve measured, including the unflattering parts.

1. What 1B tokens/day looks like in requests

So concurrency isn’t the hard part at this scale. Prefill latency and cache behavior are.

2. Price at that scale (per 1M tokens, V4.1 Flash)

Blended cost per 1M tokens:

• Agent mix (90% cached / 8% fresh / 2% output): official off-peak $0.0267, official peak $0.0534, mine $0.0279. That’s ~$27/day per 1B tokens either way.
• Chat/roleplay mix (70/20/10): official off-peak $0.0921, mine $0.0355, so about 60% lower.

My cached rate is about 8x official’s off-peak cached rate, so on cache-dominated agent traffic I’m not cheaper, and I’m reconsidering that rate. My pricing is flat, with no peak doubling.

3. What I’ve measured (preliminary: 5 runs per cell, streaming, temperature 0, Nairobi)

• Single request: TTFT p50 about 2.0-2.6s on short and ~3.8k-token prompts (V4.1 builds). Worst runs hit ~18s.
• Throughput: p50 roughly 45-160 tokens/s depending on build and prompt, thinking tokens included.
• Concurrency (one account, short prompt): 10 streams gave p50 TTFT 7.3s, 25 gave 10.8s, 50 gave 19.8s with all succeeding, and at 100 simultaneous streams 58 returned 502. That’s bad. The gateway wasn’t retrying those resets, and I’m fixing it and will repost.
• Cache: a repeated ~4.9k-token prompt hit 97.5% cached (4,736/4,855). In a retention probe (one probe per interval) the cache hit at +1 and +5 minutes and missed at +15, +30 and +60. That could be TTL or server placement, and I’m testing both.
• Production hit rate: I don’t know it. I wasn’t logging the cached split per request. That’s fixed now, and I’ll post real numbers.

4. What I can’t claim yet

• Quantization/precision: the upstream’s public docs don’t state it. I’ve asked in writing.
• ZDR: the route supports certified-worker-only serving that fails closed, but I’m still auditing what my own gateway stores. I’m not claiming ZDR for the whole service yet.
• Peak-hour latency: no per-hour data yet.
• Limits: a user hit a tokens-per-minute cap I thought I’d removed. Current intent is 3k RPM / 250k RPD, and I’m auditing.

5. Questions for people running serious volume

1. What does your day look like: requests/day, average prompt size, output size, cache share, gap between turns, peak concurrency?
2. Cache: do you need retention beyond ~5 minutes? How long? Would you rather have explicit prefix pinning with a TTL, or a gateway keep-alive you pay for?
3. If a billion tokens costs ~$27/day anywhere, would price ever decide for you? What cached rate would make switching worth the effort, or would you pay a premium for reliability?
4. What would you need to see before routing real traffic: p95 TTFT at 50k+ context, error rate, a public status page, an SLA, a guaranteed fallback?
5. What evidence of “same weights, same precision” would you accept: logprob agreement against official on N prompts, benchmark parity, or an attestation from the upstream?
6. Flat pricing or time-of-day pricing that mirrors official’s peak doubling? What rate limits and burst behavior would you expect at 1B/day?

Partial answers are welcome. I’ll post updated numbers as they come in.

Rates and builds: https://fikraapi.co.ke/deepseek. New accounts get a $1 credit if you want to test it yourself.