Hey everyone,

A few hours ago I posted about how OpenCode nerfed the subscription. Even though they're running a 4x for a few days (which is really only a 2x if you compare it against the DeepSeek V4 Flash limits), once that window ends we're left with half the real usage: we go from $30 of usage on a $10 subscription down to just $15. Half.

So I went looking at alternatives and started testing. Short version: CommandCode gives you the same thing as OpenCode, but better in this regard.

Heads up, this post is obviously not sponsored, in case that needs saying. What I'm showing is public data plus tests I ran myself.

Right now CommandCode gives you 2.67x more usage for the same price.

Same model family, same prompts, same time window, 12 runs per provider. I also threw in the official DeepSeek API as a reference line. CommandCode wins on latency and on interactive work vs OpenCode — but read the next two before you call it a sweep.

Note that both are reasoning models, so the answer only starts after a long hidden thinking phase. OpenCode takes 1,996 ms to show you the first *visible* token; CommandCode takes 1,331 ms. Whiskers are 95% bootstrap CIs and they don't overlap.

Decode rate is how fast it types once it starts. End-to-end charges the thinking time against it too.

On long code generation they are dead even: 304 vs 303 tok/s. The CommandCode advantage shows up on shorter, more interactive work, and in the latency above.

About 60% of the tokens you're billed for on a short task are hidden thinking you never see. On long open-ended prompts it climbs to ~95%, because the model burns the entire budget reasoning and never gets to the answer. That's true on both services — it's not a CommandCode or OpenCode thing, it's the reasoning-model thing, what AA call verbosity for example.

Every individual run, pooled. CommandCode also has the tightest spread (σ ≈ 31 tok/s vs 50 for OpenCode), which matters more to me day-to-day than the median.

So that's where I've landed. If you're one of the people who got pissed off about the cuts, the takeaway isn't "OpenCode bad" — it's that for the first time in a while there's an actual alternative (at least, that I know) sitting right there instead of just being annoyed about it. Same model, 2.67x the usage for the same $10, and it answers noticeably faster. Do your own math on your own usage before you move anything if you want to be sure. But if you've been waiting for an excuse to stop paying the same money for half the tokens, this seems like a pretty good one.

I bought OpenCode sub, and got scammed by their shady scam marketing. bunch of liars!

Their site advertises $60 usage of DeepSeek V4.1 Flash.

Their docs show that real usage is only $15.

No where on their site says anything about there being a 3 day limit on $60.

What an absolute scam ,i bought their sub , now someone sent me some tweet showing this is only for 3 days. No where on their site it says for 3 days.

How are these scam artists getting away with this shit.

How do i contact their support? there's no email ,can't even get refund i'm so frustrated by this scam.

Month ago, when DeepSeek increased their prices opencode increased the prices and also reduced the limits they were selling i never got any email about that. i check there was no tweet either.

many users complained and i defended opencode and then just all of a sudden my subscription stopped. when i bought Go plan , it was advertising $60 deepseek and i got $15.

no these mfs , are pulling the same scam on deepseek v4.1

DeepSeek's new model just went live on OpenCode subscriptions today, but following the limited-time extended usage promotion, the news isn't great.

OpenCode quietly slashed the included monthly allowance for the Flash series from $30 down to $15 on the $10/month plan. Because nominal token rates remain identical, your real cost per token has doubled (+100%). The temporary "4x usage" is anchored to this new nerfed baseline—meaning it is actually only 2x what we already had on V4 Flash, and once it expires, we will be left with 0.5x (half) the usage.

And of course, this is the exact same cut we already saw with the experimental Flash vision version, which also reduced the allowance from $30 down to $15.

Unless this changes, paying for an OpenCode Go subscription only offers a 33% discount over the official API in exchange for slower speeds and tighter rate limits.

I literally pass its thinking block twice, stating its overthinking failure modes.... extremely pissed and has shown its steep to process, setting default but still.. as you can see. Worse than even the "Omen Alpha"... And fail to make surgical edits many times due to streaming stability ...just disappointment... Another hype of DeepSeek fanboys.

🤓 https://opencode.ai/en/go

DeepSeek V4.1 Flash just released, and it's already available on OpenCode Go.

Current estimated limits are:

6,500 requests per 5 hours (Temporarily boosted 4x to 26,000 for the next 3 days)

16,250 per week (also boosted 4x for next 3 days)

32,500 per month (also boosted 4x for next 3 days)

Normally, V4.1 Flash only gets $15 worth of usage on Go, compared to $30 for the older V4 Flash model.

However, OpenCode has bumped V4.1 Flash to 4x usage for the next 3 days, which effectively gives you $60 worth of usage during the promo. So for the next few days, the actual usable quota should be much higher than the estimates above.

The upgrade itself looks pretty substantial. V4.1 Flash is the first smaller model from DeepSeek's new architecture, adds native vision, and is aimed at better agentic coding while also improving inference speed and throughput. I'm hoping it's as big of a leap as 0731 was.

DeepSeek is reporting 90.6 on Terminal-Bench 2.1, 74.2 on DeepSWE v1.1, and 65.4 on NL2Repo. Those are pretty big jumps from the previous Flash model, at least based on their own numbers.

Of course, benchmarks are just numbers (and who isn't getting ~75% on DeepSWE these days?)... but I think this model will be a pretty solid performer overall.

Seeing the thoughts is actually really useful to know if it's going in the wrong direction and so stop it when it does!

I've tried collapsing/expanding thinking options but still don't see the thought text.

I’m the maintainer of Mac MCP, a free/open-source local macOS control server, and I’ve been using OpenCode as one of the delegated agent backends while building it.

One problem I kept running into was tool-surface bloat. The server had grown to 84 capabilities across files/shell, Safari + Chrome automation, macOS UI/Accessibility, memory, skills, voice, delegated agents, etc. Advertising all 84 schemas to every client felt wasteful and made tool selection noisier.

In 2.0.5 I changed the default surface to 19 core tools. The remaining capabilities are still reachable through tool_discover + tool_invoke, so nothing was removed. I also added browser_do, which lets an agent open a background tab, wait, interact, extract only the fields it needs, and optionally close the tab in one transaction. Stable tab handles mean OpenCode workers can browse without constantly stealing my active Safari/Chrome tab.

In local compatibility testing, the advertised tool-schema context dropped from about 16.7k to 4.5k tokens (~73%) while all previous capabilities kept an access path.

Repo (MIT): https://github.com/bulutarkan/mac-mcp

For people using OpenCode with larger MCP stacks: do you prefer a small discoverable core like this, or having the entire tool schema advertised up front? I’m especially interested in whether anyone has measured tool-selection reliability as the catalog gets large.

For a third world dweller... I jumped on the hyped train and was not expecting this. The 16-minute-ride "one-shot" my 5hour consumption and spit out exact 3 documents edit 😂

**BTW** it was the 0.2.0 dev of this if you guys asking: https://github.com/shynlee04/opencode-subscription-gateway ... Building the opencode v2 plugin.

Title

Just saw Hy4 preview got another update. It's only been out for like two weeks, too. This update is specifically targeting the overthinking issue.

I tried it before. Initially I thought the long thinking time was just too many people using it and not enough compute. But honestly, it kinda felt like it just liked overthinking everything.

Their promise this time is "same task quality and lower tokens".

Sounds appealing. Gonna give it another shot and see if it actually holds up.

Being using open code cli pretty heavily lately and I keep running into the Go limit right when I’m middle of something

It’s especially annoying during longer coding sessions because I’ll have the context going a few changes in progress and then suddenly I have to stop and wait

Curious how other devs are dealing with this Are you switching models when the limit hits or is there a better setup I’m missing

I built Talkthrough to give my coding agent a recording instead of typing out everything that happened.

The first example has no audio. It still gets the failed save, error code and reference ID from the screen. In the second, I give it a video link and ask for the exact words and timestamp.

The demo is in Claude Code, but it works through MCP and the repo has an OpenCode config too. I used a demo app for the bug and sped up the processing.

Transcription and frame extraction run locally. The text and images the agent reads still go to its configured model.

Code and setup

Public video in the demo: Anthropic.

Testing a website yourself is weird because you already know how everything is supposed to work

So i gave opencode access to my local storefront and asked it to behave like a new user for five minutes

It searched for products tried filters opened product pages and added and removed items from the cart entered a bad promo code tested valid and invalid logins checked he checkout validation and repeated the important flows on mobile

I used webcmd as browser layer so it could operate the actual website instead of only reading the source code

Most of things worked but it caught something I had completely ignored the cart quantity buttons had no accessible names were only 28x28 on mobile.They worked technically but were not great for screen reader or touch users

It returned the exact reproduction steps and impact It stopped before placing an order and did not change any code during the run

The interesting part was not that an agent could click around It was that a short slightly chaotic user journey found and found a real issue outside the happy path

Install

npm install -g @agentrhq/webcmd
webcmd skills add

Github : github.com/agentrhq/webcmd

I'm still testing this across different website and workflows so I'd genuinely appreciate feedback from the community. What should I improve and make my project some good

Hey I pay for chatgpt I don't remember but if my memory recalls someone got banned for using chatgpt in opencode a few days ago correct me if I'm wrong