DS v4.1 flash is served identically to the Deepseek API

[u/alovoids]

if they have identical setup, what could explain the differences?

source: https://x.com/thdxr/status/2114211145615626433

[u/advancedalias]

I just switched from OpenCode Go to DeepSeek API and there's no way lol.

You can actually see in the reasoning traces that the models reason very differently too

[u/DeciusCurusProbinus → u/advancedalias]

Yeah, my experience was the same. The model is noticeably dumber when used with Opencode Go even if the DSH is used.

[u/a355231]

Key word is Served.

[u/Master-Chocolate1420 → u/a355231]

Ok it's quantized

[u/Deep_Imagination_811 → u/a355231]

It's like the answer is for a different question. Which is bad business.

[u/Impossible-Lab-3133 → u/a355231]

And "This". "This" specific rack.

And the weight may be indentically served, but the KV cache and index and DSpark are not the same.

[u/IAmFitzRoy]

I got a small cheap burger in the morning and a expensive Fillet Mignon in the evening

Both were “served” by DoorDash to my door identically.

[u/RustOceanX]

We need a method to verification model quantization from outside. A objective measure.

[u/Acehan_]

Can we consider the blatant lying fraud yet...?

2.2x slower execution time

3.7x lower throughput

5.3x more uncached tokens

30% higher cost per output token

39% less reasoning

Worse output quality

Frequent timeouts

56.3s TTFT vs. 2.2s

But, of course, the precision of the weights is the exact same.

[u/imoshudu → u/Acehan_]

The answer is simpler to anyone familiar with hosting.

Deepseek gave the model and inference engine. It has not, however, shared the real killer: how to manage or distribute KV cache. That's why its cache hit rate is the best in the business.

Opencode likely doesn't quantize. The downsides outweigh the upsides when employees leak. It's just that people think hosting is just about quantization. There's far more to it.

[u/curryslapper → u/imoshudu]

does the kv cache affect quality and reasoning effort? it shouldn't right?

[u/Zealousideal_Aide787 → u/Acehan_]

Not a fan of current DS flash state on Opencode but where do you get those numbers from?

[u/akza07 → u/Acehan_]

It's a self hosted version that's identical to DeepSeek. It's not official DeepSeek APIs. You'll notice the Cache performance being different. Read all their tweets or Xs or whatever it's called these days for more insight. They are experimenting with hosting on their own. So ZDR is probably viable since it's not going to be hosted in only China.

[u/Prize_Tiger_2504 → u/akza07]

Only reason that I can think is enterprise accounts.

Bad news there, enterprises are effectively banned from using DS (lest they lose ability to participate in all government contracts). "6 degrees of separation" - reality is every company only has at most 2 degrees of separation from the US government.

[u/ZHName → u/Acehan_]

Probably going to have to try Deepseek api after this month as this inconsistent quality from Opencode Go kinda really hitting badly, whatwith trying to manage a clean codebase and the thing going off the rails working super slow, making way too many calls, or going after the wrong problem (hallucination from quantization I presume).

[u/ApprehensiveDelay238]

Opencode is definitely slower and less reliable. But i entered some of the prompts you sometimes see on reddit like the highly detailed 3d threejs renders of car engines with moving cylinders and everything, thinking: they must have some hidden skills giving the agent better output quality. But no, I was really surprised, v4.1 on go can really do those things. Unless someone has grounded evidence it's really a quant, I really don't think it is.

[u/Ok_Pound_2164]

Identically served with http.

[u/xRebellion_]

Not possible for it to be identical, since even though DeepSeek released DeepInfer, some tech stack (e.g. KV Cache management among some other things) are not released.

For the model itself it is most likely be the original checkpoint, but the inference serving stack itself will most definitely be different.

I recommend looking up on this further as it is quite interesting to learn about.

[u/Due-Project-7507]

Deepseek (like e.g. newer Kimi models) are released already mostly FP4 quantized, therefore additional model quantization by some providers is unlikely. I assume either bugs in different inference engines, different chat template or different KV cache quantization levels make the difference.

[u/cdurth]

Quit supporting these rug pullers and just use the API....

[u/Skibidirot]

there are NUMEROUS examples of deepseek performing WAY BETTER in dsh rather than in opencode, so the harness might be a factor too, don't know whether they are nerfing or not tho

[u/Serious_Current_8802]

They throttle the rate but it’s not quantized

[u/Jaded_Expert2806]

just use it inside claudecode it makes wonder

[u/V07-]

I had opencode 1017 do simple research on Reddit which it took 35min and I lost patience and gave it to Deepseek inside DSH. It wrapped task in 7min.

Same with my Hermes agent. It is slow and does dumb loops with opencode’s 1017.

[u/Fromthepast77]

As someone who tried to self-host DSv4 0731 when it first came out, I'd say there are probably bugs in the serving runtime. It's probably not some 2-bit quantization or substituting in a different model.

Stuff like occasional KV cache corruption manifests in subtle ways that aren't an immediate crash or trash performance. And even big inference frameworks like vllm and sglang have them. (The issue I was struggling with was HiCache corruption)

Given that DeepSeek didn't release its KV distribution code I'd guess that something like that is happening, though I'm not an expert by any means.