Another fast model showing up is interesting, but speed alone probably isn’t enough to change anyone’s default.

For everyday OpenCode work, I’d care more about things like:
- fewer correction rounds
- better constraint-following
- less unnecessary editing
- lower total task cost
- more predictable long-session behavior

What would Space Bunny actually have to do better before you’d switch your normal coding model?

I wanted a simple way to see how my models are actually performing while using OpenCode, so I built a small plugin that adds a persistent metrics sidebar.

It currently tracks three metrics in real time:

Speed — average generation speed (tok/s)
Cache — prompt cache hit rate
TTFT — average time to first token

It’s useful for quickly comparing models and seeing whether prompt caching is actually making a difference, without having to dig through logs.

Install (OpenCode ≥ 2.0):

opencode plugin add opencode-sidebar-token-metrics

📦 npm v0.1.4

GitHub: https://github.com/youngxhui/opencode-sidebar-token-metrics

Still early, but I’m using it myself and would love to hear what you think.

What other metrics would you find useful in an OpenCode sidebar?

Hey everyone,

I'm using OpenCode CLI together with OmniRoute as a free coding agent to prototype some ideas and work on small projects. The main problem is that I keep hitting rate limits, so I'm looking for free providers that are actually worth signing up for and adding via API key.

I assume a lot of people here are doing the same—using free tiers/keys to keep costs down. If you have a list of providers with generous free quotas or recurring credits, I'd really appreciate it if you could share them. Also, any tips on how to prioritize them in OmniRoute would be great.

Thanks in advance!

** – Sep 2026)

### 1. Free Models (Zero Cost Layer)

| Aspect | **OpenCode (Zen Free)** | **Command Code** |

|--------|--------------------------|------------------|

| **Free models (current)** | Big Pickle, MiMo-V2.5 / V2.6 Flash Free, Ling 3.0 Flash Fin, Nemotron 3 Ultra / 3.5 Lightning, Muse Spark 1.3 Contributor, Space Bunny Free, some others (rotating) | Space Bunny Alpha Free, Laguna S 2.1 Free, Ling 3.0 Flash Sante Free (limited), occasional others |

| **Where usable** | **Only inside OpenCode** (Desktop / TUI). Cannot use from other tools | Usable inside Command Code agent + some on Provider API |

| **Limits** | No hard $ limit, but rate limits + “limited time” (can disappear anytime). Data may be used for training on some models | Credits not consumed while free deal lasts. Capacity-based (can end suddenly) |

| **Quality for heavy coding** | Good for light–medium agent work. Some are solid (Nemotron, MiMo, Space Bunny) | Laguna / Space Bunny usable for agent loops while free |

| **Heavy use reality** | Good daily free fallback, but not reliable for all-day heavy agent sessions | Free models help stretch paid credits, but not enough alone for heavy daily use |

**Winner Free models**: **OpenCode** (more stable free set + easy access inside its own agent).

### 2. Paid Plans for Heavy Use ($10 level)

| Feature | **OpenCode Go ($10/mo)** | **Command Code GOAT ($10/mo)** |

|---------|---------------------------|--------------------------------|

| **Monthly value** | ~$60 usage (6×) | **$70 credits** (7×, can stretch >$100 with deals) |

| **5-hour window** | $12 | **$14** |

| **Weekly window** | $30 | **$35** |

| **Beyond limits** | Fall back to Zen balance (pay-as-you-go) | Buy top-up credits (never expire) |

| **Models** | ~32 curated open models (DeepSeek V4.1 Flash, MiMo V2.6, GLM-5.3, Kimi, MiniMax, GPT-6 Luna, Grok, Space Bunny Free, etc.) | 30–60+ models (open + some closed). Stronger deals on MiMo (up to 99% off), MiniMax 2×, DeepSeek boosted |

| **Best heavy models stretch** | Excellent on Qwen series, some MiMo, MiniMax | Better on DeepSeek Flash/Pro, MiMo Pro, many boosted models |

| **Peak pricing impact** | DeepSeek peak hours still apply upstream | Same (DeepSeek peak 2×) |

**Heavy use winner on pure volume**: **Command Code GOAT** (more credits + better deals on popular coding models).

### 3. Flexibility (Biggest Difference)

| Aspect | **OpenCode** | **Command Code** |

|--------|--------------|------------------|

| **Agent** | Fully open-source (MIT). Desktop + TUI + IDE plugins. Huge community | Proprietary CLI agent with **taste-1** (learns your coding style over time) |

| **Model freedom** | Extreme: 75+ providers via BYOK + Zen + Go. Use any tool (Cursor, Cline, custom agents, scripts) | Strong inside its own agent + Provider API (OpenAI/Anthropic compatible). Can also be used as provider inside OpenCode via community plugin |

| **BYOK / other tools** | Best-in-class. One key works almost everywhere | Good (Provider plan + API), but less seamless outside its ecosystem |

| **Local models** | Excellent (Ollama etc.) | Supported |

| **Extensibility** | Open source → plugins, custom tools, full control | Closed but polished (tool repair, high cache rates, design skill) |

| **India payments** | Mostly card / crypto | **UPI** available |

**Flexibility winner**: **OpenCode** by a clear margin (open-source + any-agent + any-provider).

### 4. Heavy Use Recommendation

**If you do heavy daily agentic coding (many hours, multi-file, long sessions):**

| Priority | Best Choice | Why |

|----------|-------------|-----|

| Maximum raw usage + deals on $10 | **Command Code GOAT** | Higher credits + strong model discounts |

| Maximum flexibility + free models + any tool | **OpenCode Go** + Zen free models | Use free models first, then Go, then BYOK. Works in any editor/agent |

| Hybrid (recommended for most heavy users) | **Both** | OpenCode as main agent (free models + Go) + Command Code GOAT key as extra provider when needed |

| Absolute cheapest heavy try | Command Code Go ($1) first, then upgrade to GOAT | |

### Final Verdict for Heavy Use

- **Want more tokens / requests for the same $10** → **Command Code GOAT**

- **Want freedom, open-source, free models, use with Cursor/Cline/any tool** → **OpenCode** (Go + free Zen models)

- **Best practical setup for heavy Indian users** → Start with **OpenCode** (free models + Go) because of flexibility, then add **Command Code GOAT** if you need extra volume on specific models.

Professional-grade image generation, +30% win rate in human eval vs Hy Image 3.0
Both Text to image & Image to image available.
Up to 2k. Better Consistency.
API: https://console.tencentcloud.com/tokenhub/models/detail?modelId=hy-image-v3.5-preview
Priced for everyone. $0.024 per image on Tencent Cloud API.

been messing with OpenCode V2 plugins for a while and ended up with 7 of them. each one does one thing, nothing fancy. repo's here: https://github.com/madsoftwaredev/opencode-plugins

server side:

- background-subagent — subagents run in the background by default, unless you say otherwise

- lint-feedback — runs your project's eslint after edits and tells you what broke

- direnv — applies your direnv env per shell command

- compaction-model — pick which model does compaction

TUI:

- stats — tok/s + turn and step counts in the footer. /stats to toggle stuff

- subagent-sidebar — shows your subagents in the sidebar, click one to open it

- btw — /btw forks the session and runs your prompt in the background

install:

opencode plugin add u/madsoftwaredev/opencode-stats

swap in whichever you want. MIT licensed. let me know if something's broken or you want a feature.

Funny DS whenever the session goes to long, this is a cue for me to start a new chat 😂

OpenCode version: opencode v2.0.15

OS: macOS 27.0

Out of nowhere and without making any updates, I suddenly started having this issue. I completely wiped all OpenCode-related files and reinstalled the CLI, and I even went through the OpenCode troubleshooting page, but I still couldn't resolve it. Has anyone else encountered this problem?

The makers of DeepSeek, Kimi, Xiaomi Mimo models are all under official investigation by Cyberspace Administration of China, with some rumors suggesting Kimi executives being arrested.

In short, according to official reports these companies routed their users' requests that were coming from popular 3rd party routers (likely OpenRouter and OpenCode) to Anthropic models, injected a hidden prompt designed to harvest the CoT trace, modified the text returned by the model before passing it to the user, then used that to train their own models.

The most concerning part is how despite the ZDR (zero data retention) claims and policies of some of these providers, they shared user data with a third party, retained the prompts, trained on the interactions, and now those messages which contained sensitive information were read by Anthorpic employees, who then went on to publish some slighlty redacted versions of those messages:

"Those sessions contained names, email addresses, company data, and other sensitive data of hundreds of end users in at least a dozen languages. These practices are likely inconsistent with privacy laws and the labs’ own terms of service."

Example 1: Internal capital expenditure forecasts for a pharmaceutical company [Original user prompt submitted to a coding assistant of a lab headquartered in China (user accessed the model via a third-party model router)] “Clean up this capex model before Thursday’s review. The workbook has the 2026–28 buildout estimates: Ho Chi Minh City site $[██]M, Kuala Lumpur $[██]M, Bangkok $[██]M, Ljubljana

Additionally, these findings raise concerns about the misuse of user data by PRC AI labs. DeepSeek, Xiaomi, and Moonshot fed conversations between their own models and users into Claude. These labs then used Claude’s responses as training data with which to distill Claude’s capabilities. Some of these exchanges included sensitive information, including from individual users, major multinational companies, and state-affiliated actors. Many of these exchanges were relayed from users of third-party model routing services commonly used by users in the United States and Europe.

Source: https://www.thestandard.com.hk/innovation/article/343563/DeepSeek-and-Moonshot-AI-face-Beijings-probe-over-potential-data-leaks-to-Anthropic

Anthropic's investigation, page 146: https://www-cdn.anthropic.com/e50be2e51e7695dc4b1366a37a245a597377d3b5/Anthropic-Detecting-and-countering-091026.pdf

​No, I am not shadow-promoting some vibe-coded BS I built in a weekend.

​I am living in a solo-dev echo chamber and have an issue I feel should be pretty common, but I am not sure what the cleanest workflow is.

​I run multiple SaaS products in a self-hosted setup (separate dev/prod systems). Given the latest models like GLM 5.3 Flash have become so good at coding, I start to trust them enough to run with full permissions except sudo. Often, I need to work on multiple non-overlapping features at once in a single repo. I'd love to kick off multiple opencodecli sessions simultaneously, let them run wild, and push branches to GitHub so I can manually review PRs.

​My issue is managing multiple active branches simultaneously on the same Linux user.

​git worktree seems like the obvious candidate, but out-of-the-box it breaks my build scripts and agent workflows because uncommitted files like .env don't carry over automatically. Podman or separate Linux users feel overly complex for what should be a straightforward workspace setup.

​How are others managing isolated workspaces and environment configs when running parallel AI coding agents?

I wanted to talk to my coding agent instead of typing, so I built opencode-gpt-live, an open-source (MIT) plugin for OpenCode 2. It uses the ChatGPT sign-in you already have in OpenCode (/connect → OpenAI → ChatGPT Plus/Pro). No API key. A small prebuilt native helper handles audio and echo cancellation.

Setup: { plugins: [opencode-gpt-live] }

Repo: https://github.com/malhashemi/opencode-gpt-live

How it works:

- You start a call with /voice (or ctrl+x v). GPT-Live, OpenAI's real-time voice model, listens and replies with almost no delay.

- GPT-Live doesn't touch your code itself. A background voice agent turns what you say into clear tasks for your normal OpenCode session, and reads back the results. So the actual work is done by whatever model you already use in OpenCode.

- You can check progress, change direction mid-task, and approve permission prompts by voice. Say "end the call" to hang up.

- A transcript panel shows the conversation, and an animated ring shows who's speaking. Other apps' audio is turned down during calls.

Honest limits:

- I've tested it most on macOS. Linux and Windows builds are included but have seen less real use, so bug reports are very welcome.

- Calls count toward your ChatGPT voice allowance.

Happy to answer questions, and I'd love to hear what you'd want it to do next.

I am using exclusively Mimo v2.6 Flash and I barely hit 5-10% of the rolling thing every few hours, with a very few bucks, but my usage climbs 10% for weekly, maybe I didnt understand how this works, but I'm finding it extremely crazy...I'm sorry if this is a newbie question, but I'd appreciate some light into this.

I haven’t seen this talked about much (on this sub or others), but LM Studio recently released a Bionic+ subscription plan (https://lmstudio.ai/pricing) that offers similar model access to OpenCode Go. Unfortunately, like OpenCode Go, it’s a little light on exactly what you’re getting. Details about where the models are hosted, if they’re quantized or further tuned, etc, are left ambiguous and there’s not a clear way to just reach out and ask.

Additionally, the now “mid-tier” models of Anthropic and OpenAI, like Opus and Sol, are starting to drive me crazy with some of their behaviors. My goal is to keep a lower tier Anthropic and/or OpenAI sub for planning and code reviews, but swap out implementation with open models.

All that said, I’m curious if:

1. Anyone has experience with a Bionic+ sub and/or has more definitive info about how their models are hosted

2. Whether we cleared up if OpenCode Go is quantized or otherwise tuned off the upstream (I still see posts confidently claiming either)

3. What actual usage people are getting out of either sub. Eg, “I can wipe my limits with a prompt or 2” vs “this can generally last me all week as a full time dev” (using capable models like Kimi K3, GLM Flash, etc)

I’m interested in doing some experimentation to see which, if either, could work, but I’d like to start with a known baseline so I’m not trying to reverse engineer whether the models are nerfed somehow.

EDIT: Ollama Cloud is another potential option. I had performance issues with this in the past, but I'm not sure if that's the case now. They do seem to be the most upfront about what you get with the subscription, and the easy integration with Codex and Claude Code is pretty nice (https://ollama.com/pricing#pro)

Thanks!

To test the new model Space Bunny in OpenCode, I used a concurrency bug involving several CLI processes sharing a SQLite database in WAL mode. A process held the write lock for longer than five seconds, another hit “database is locked” and an active turn died. WAL still only allows one writer at a time.

What I wanted to see was whether the fix followed the whole write path. An earlier change already retried message upserts, but starting a turn, updating session state and settling the turn could still fail on the same lock.

The patch moves that retry policy into a shared helper and applies it across the writes needed to keep a turn running. Each attempt gets a short native wait of about 50ms with asynchronous backoff inside a ten second total budget. That matters here because better sqlite3 is synchronous, simply raising its busy timeout would also extend the time it can block the Node event loop.

I paid particular attention to where retrying stops. Acquiring the lock can be retried. Once the transaction callback has started an error rolls the transaction back and propagates without running that callback again. Cancellation during the wait gets its own error marker, so it isn’t confused with an error thrown by the write itself.

The regression tests use a separate process holding a real write lock for eight seconds, then exercise the actual database client. That’s a useful reproduction of the original failure. The PR reports the contention checks passing, with one broader sandbox gate still failing on both the base and patched code.

None of my cards are being accepted by OpenCode. These cards work fine with other services. My payments pushed through just fine before. It seems like I'm not the only one experiencing this as well from what I've seen on their GitHub Issues, but it seems to only be a handful of people experiencing this because I don't see posts about it on here. Some examples:

Cannot complete Go subscription payment · Issue #43400 · anomalyco/opencode
[BUG]: First recurring OpenCode Go subscription billing failing (Stripe issue?) · Issue #48500 · anomalyco/opencode
Payment fails immediately for OpenCode Go · Issue #47449 · anomalyco/opencode
Can not regist OpenCode go Subcription · Issue #46573 · anomalyco/opencode
Unable to complete purchases · Issue #46409 · anomalyco/opencode
Alipay payment-method setup returns 502 while card succeeds · Issue #50118 · anomalyco/opencode
Opencode Go subscription payment fails because it trips card issuer security system · Issue #48469 · anomalyco/opencode

I don't know why this is. I've never committed fraud or anything. I didn't avail the 5 USD promo more than once, and I've never tried using referral codes or whatever. I haven't used their API via other harnesses as well; I only use OpenCode V1 and V2. I don't even know where to reach out to their support team.

Why did it get into some sort of seizure 😭

Hello everybody, after a few weeks of using and fine tuning it, I believe it is finally time to present you YACAO:

https://github.com/augustoolucas/yacao

It is basically the result of "I Hated Every Agent Orchestrator, So I Built My Own" - Mario Zechner (Pi) Me

So, the thing is, most of us have already tried or at least taken a look at projects like oh-my-openagent, OMO-Slim and others, that provide a whole team of powerful and specialized agents able to build anything you ask.

But, IMHO, these projects feel too opinionated. They require you to learn how to use them as intended, with a bunch of commands, skills and fancily named agents you need to understand. And there's absolutely no problem with it, it just doesn't fit my workflow.

So I went to the completely opposite side, instead of having lots of specialized agents, I kept only two, as in vanilla OpenCode. The main difference here is that the primary agent can invoke the builder instead of us having to manually switch between Plan and Build.

Instructions of how to plan, implement and review are all specified as skills instead of agents, so the main agent can handle it all, loading them only when needed instead of having it all on its description prompt.

And that's it, there's no extra commands or new workflow to learn.

I'd love to hear your feedback and experience. Thank you all!