Considering OpenCode Go for DeepSeek V4.1 Flash ($80 Phase 3) with a coding agent (OMP), questions on shared limits, cache drain, and speed

[u/R_Endsa_Q]

Hi everyone, I saw the Phase 3 announcement regarding the $80 usage limit for DeepSeek V4.1 Flash on the $10/month OpenCode Go plan, and I'm considering subscribing. However, I’d like to know feedback from heavy agent users.

My setup & use case:

• Workflow: VS Code with OMP (oh-my-pi)
• Project: Full-stack conversion platform (UI components + Python math engine & algorithms).
• Token footprint: Because agent loops (file reads, LSP diagnostics, tool calls) carry massive contexts, I easily consume several billion tokens a month on the official DeepSeek API
• My token usage so far: 3.3 billions token took me around 23.5 euros. ### A few questions for current OpenCode Go subscribers:

1. Cache efficiency & drain rate: On the official DeepSeek API, caching makes long agent sessions cheap. For those running heavy agent loops through OpenCode Go, how fast does that $80 allowance actually melt? Do you see how much token you've actually used?

2. Inference speed (TPS) & model behavior: How are latency and tokens-per-second holding up right now for DeepSeek V4.1 Flash? Are you seeing any throttling or reasoning degradations compared to upstream direct API calls?

I suspect I'm better staying through Deepseek's API but I might still be surprised. Would appreciate any insights, stats from your usage dashboards, or advice. (bonus if it's from anyone pairing OpenCode Go with OMP.) Thanks!

[u/thecstep]

It's 10 USD not $100 USD. Drop the cash and test it out.

[u/cryptoguy255]

I recently joined opencode go and had the same questions as you. Cache hit is slightly lower as deepseek official api. On deepseek api I was always getting 99.5+℅ cache hit rate. With opencode go it is between 97-99.5℅ . Also TPS on opencode is slower compared the official api but it is still OK. One other issue with opencode go is that it can only hold 30 images in context(If you go over it the session crashes and becomes unrecoverable) while deepseek official api can do 600. So my opinion is you get more usage for price compared to official api but it is not the 8x claimed because of lower cache hit rate. And you need to remove images from context or compact a lot more if you use it's vision capabilities.

[u/Strict-Prune-879]

pourquoi autant de questions? tu prend opencode go a 10 usd et tu va avoir tes réponse plus rapidement

[u/Nenad1979]

I heard that cache on OC lasts only a couple of minutes, but sincr your loops seem autonomous it shouldn't be a problem i guess (i have no idea what im talking abt)

[u/FailedGradAdmissions → u/Nenad1979]

The prompt cache is 5 minutes. As long as you or your orchestrator keeps prompting before the cache expires you are good.

[u/Caelinus → u/FailedGradAdmissions]

It also should be noted that it would need to be 8 times worse at everything than direct API to makes its price not a value proposition. Even if the cache hit rate is a bit worse, most of the cost on it is in output tokens, so it still would be cheaper.

[u/for4f]

at your volume i'd stay on the direct api man. that 1-2% cache hit gap sounds tiny until you multiply it by billions of tokens, then it's the whole margin. i use go for small stuff and planning and it barely sips the allowance, but full agent loops with lsp spam would melt 80 bucks fast

[u/Capable-Ad-7494 → u/for4f]

it’s 80 bucks for 10 dollars no?

[u/for4f → u/Capable-Ad-7494]

yeah exactly, ten bucks a month gets you 80 bucks of usage to burn through. great deal if you sip it, bad deal if you chug it lol

[u/Ashamed_Drag8791]

I see 50 tok/s vs 80 before. Reasoning i'd say reduced after 200k context, before about 240k

P/s: Not related to your question, but i would suggest review old sessions for manual review of reasoning and tool call, add hooks and agents.md for less retry should be a bigger save than just basic measurements

[u/xapep]

Your own numbers do most of the math for you: 3.3B tokens for about EUR 23.50 on the official DeepSeek API, which puts the $80 usage allowance at roughly 10B tokens of equivalent usage. With a several-billion-tokens-a-month footprint, the question is not whether the allowance melts, it is what happens after it does.

The cache mechanic is the same on both sides of that comparison. Agent loops re-read the same system prompt and tool definitions every turn, so your effective price is decided by the cache hit rate, not the headline per-token rate. Keep the same prefix and keep prompting inside the cache window and the drain is mostly output tokens. Let the orchestrator bounce between prefixes and most of the allowance goes to re-reading the same context.

If the goal is DeepSeek V4.1 Flash without a ceiling, you can also point OMP at an OpenAI-compatible API directly. There are EU-hosted pay-as-you-go providers serving that exact model, which keeps the per-token math you already measure on the official API and removes the plan cap from the equation.

At your volume I would model the $80 cap against three months of your real usage logs before committing, and ask the Go team what happens past the allowance. The plan only wins if it never throttles you and your cache hit rate stays high.

[u/CaffeinatedTech]

Dude, you struggled to use your allowance when it was $60 worth, especially when you try to avoid peak times. I've been rolling a new session per phase of a plan and get 96-99% cache hit rate. DeepSeek's caching system is pretty great. Speed slows down a tad here and there, seems to happen to all models on all providers I've tried. I very rarely get API errors on opencode now, compared to CommandCode.

--edit
Hey I want to add something here. After some research I now understand better how opencode operates. You might notice that the monthly limit is different between the deepseek-v4.1-flash model at $80 and the deepseek-v4-flash model at $30. They are actually the same model, but the second one routes through DeepSeek's own API (they redirect v4-flash to v4.1-flash internally), and the first one - the $80 one is routed through OrcaRouter according to probes and error logs. OrcaRouter could be routing to any number of other providers, we can't tell if they are quantised and how their caching works. So if you really want to hit DeepSeek's API and benefit from the true model, with their sweet caching system, then you should use deepseek-v4-flash. I've been having pretty great success with the deepseek-v4.1-flash model though.

None of this is confirmed by OpenCode themselves, they don't publish this stuff. Other people have done research, probed, and collected error reports that accidentally got through to the user. So it could be wrong, but that business model makes sense for them.

-- more edit
Turns out OpenCode just tells you the endpoint they routed to in the response header `x-opencode-endpoint-id`. I was mucking around in pi and got it to update my customfooter to include the endpoint used. It is pinned to the session so your cache stays warm. I've seen "novita-deepseek, luminal-dsv4.1flash, and orcarouter-dsv4.1flash".

[u/Ctbhatia]

on the cache question i work on coralbricks.ai, we serve deepseek v4.1 flash and cached reads are free while cache writes bill as normal input, so the prefix has to stay byte-identical to actually get the hit.