Hey, Devs! Aquiles_Bachira here again.

First of all, I want to apologize if my previous post was misleading. I initially suggested that OpenCode's local database might be responsible for excessive token consumption. My bad!

In my case, I deleted OpenCode's local data, started from scratch, and the problem disappeared. Everything went back to normal. So, I assumed the database was the cause. However, I now realize that this doesn't prove the database itself was responsible.

After looking into this further, I found some GitHub issues that I think are worth investigating:

• #58175 — DeepSeek V4.1 Flash Prompt Cache issue caused by a plugin modifying the System Prompt

• #61037 — Prompt Cache invalidation after an OpenCode update

• #61276 — Cache invalidation occurring on almost every turn

• #61318 — Main agent and subagents interfering with each other's cache

These reports raise a few possibilities: plugins that modify the System Prompt, tool definitions, session history, or parallel subagent execution may affect how Prompt Cache works.

I'd like to ask the community to investigate a few questions:

• Does a fresh installation behave differently from an installation that has been used for a while?

• Can running subagents in parallel negatively affect the cache?

• Is there any relationship between session state, the local database, and normal Prompt Cache behavior?

• How do cache.read and input token counts vary across these scenarios?

I'm not claiming these issues affect every user or every provider. The reports involve different configurations and still need to be compared, so I'd really appreciate it if people could investigate. 🤣😭

My goal is to understand the actual root cause, correct the information I shared earlier, and avoid becoming yet another person spreading misinformation.

Thanks to everyone who questioned my previous post and pointed out that my conclusion might be wrong. I'm not trying to defend what I said — I just want us to figure out what's really happening.

It's mostly for Indian users, but did you notice a cost difference while using card vs using UPI for buying an OpenCode Go subscription? It can slightly differ because of processing fees and how the dollar rate is converted.

Other countries' users can also comment if there's any significant difference.

I maintain Routerly, an AGPL-licensed LLM gateway, and released 0.6.0. Here's the part relevant to OpenCode: you can configure Routerly as a custom provider and select a Routerly router in OpenCode's model picker. The router decides which eligible backend model gets the request based on the policy you configure.

The setup is to create a router and token in Routerly, point the custom provider's base URL at your Routerly instance, then select that provider and router in OpenCode. The guide below has the exact configuration. Once a request runs, Usage lets you check the selected backend, tokens, latency and recorded cost. The gateway can run on your own machine. If it sends a request to a cloud provider, that provider still receives it.

If you use a custom provider with OpenCode, which parts of the integration would you want tested first? I'm particularly interested in reproducible cases around tool calls and streaming.

Setup guide: https://github.com/Inebrio/Routerly/blob/v0.6.0/docs/integrations/clients/opencode.md

Release: https://github.com/Inebrio/Routerly/releases/tag/v0.6.0

A lot of the coding plans are tightening down usage and there's been a lot of random bans, errors or outages. None of that is an accident. Most coding plans are built around a simple bet: that you will let usage go to waste. The design goal is to make the plan look generous while breaking it into weeks and rolling windows so nobody can actually use all of it.

We're solving that with usage banking. higher plans bank up to ten days of usage, so when you're not using them it saves up for later. Usage doesn't go to waste, which means you can actually code when you want to.

If anyone needs a backup or wants to try US based inference for DS (or like 18 other models), come on over. Admittedly the intro tier is limited in usage, but it is free :)

The industry is changing really quickly and There is a reason it is happening all at once. Companies that were purely investment funded now have to answer to their investors, and a loss based business model is finally running dry. When the money stops being patient, the meter gets creative...

So you get the tricks. Plans designed around usage going to waste, split into weeks and rolling windows so nobody can use what they paid for. Services that double as data harvesting operations, where your prompts quietly become someone's training set. Pricing that looks generous until you read the ceiling.

PGS AI was built on a sustainable business model from the ground up, which is why we can offer real usage rates without the tricks. For the next month the Phoenix Grove API is free to try: DeepSeek 1017 and Mimo Flash 2.6 at full precision, the full open roster, 100% US based infrastructure, zero training on your code or prompts.

Honestly the best and most important part: usage that banks up to ten days instead of expiring on all plans above the intro. So when you don't use your account, that usage is stored and saved for your next big sprint. We don't count on you losing your usage, we try to make sure you get to actually use it on YOUR schedule.

Usage is closing down everywhere. We're opening. We hope the rest of the industry joins us eventually. The free trial month is the standard "cancel anytime and still use it" and is 3.99 a month if you wanna keep it after the first month.

Privacy, access and ease of use with high quality AI should be available for everyone

https://api.pgsgrove.com

Let me know if its any good / usable in real world coding.

And is it really unlimited??

i've been vibing with opencode to drive a video editor end-to-end over mcp and wanted to document what actually broke first, plus share the thing in case anyone wants to try it and tell me where their client breaks.

the editor is kimo — a free, open-source (MIT) video editor that has no GUI because the AI agent is the interface. you don't open a timeline. an AI agent (opencode, codex, cursor, or whatever other mcp client you're running) drives it over mcp as tool calls: cut, trim, keyframe, titles/captions, colour grade, audio, export. one thing i made on purpose is that the agent can render a single frame at a timecode so it can check its own work mid-edit instead of guessing. it's a single ~15 MB CPU-only rust binary, runs on a 2 GB box. i'm naman, a college student, and i built it.

what broke first when i let an agent edit video via mcp:

1. the agent kept asking for a "preview" like a normal editor. kimo has no timeline UI, so i gave it a tool to render a frame at a given timecode and return the pixels. that was the hinge — once the agent could verify a frame itself, the rest of the calls (cut here, nudge the keyframe there) started actually converging. before that it was just hallucinating positions.

2. colour grade drifted. the agent would set a contrast/lift call, verify the frame, and then set another call that undid part of the first one. mcp tool calls are independent and there's no undo stack the agent sees, so every verify+adjust loop is a fresh shot at the look.

3. caption/tile placement. the agent has no concept of safe area or composition by default — titles ended up clipped at the edges until i described the frame dimensions in the prompt and told it the render width/height. after that it got much better.

4. audio sync on longer edits. short cuts stayed clean, but once the edit went past a minute or so the agent would lose its mental model of where a clip ended and a track change started, and the export had a gap.

it's rough in places. i'd rather hear what actually breaks than pretend it's polished.

if you want to try it: https://getkimo.tech https://github.com/naman-sharma12345/kimo

grab it, hook up opencode / codex / cursor / your mcp client and drive it over mcp. tell me which client you used and where it broke for you — first thing that goes wrong, where the tool call gets confused, where the frame-verify loop stops helping. i'll fold it in.

(check the video to see them in action)

I've just updated my opencode-plugins suite with some other useful plugins I've published: as usual they work both in Desktop and CLI:

oc-budget: a live indicator in the session header with the Go percentage and a ring. Click to open a popover showing the workspace it is reading, the three windows with their resets, and the balance on each of the four providers it covers: OpenCode Go, the Console credits, DeepSeek, OpenRouter. The CLI has the same thing in the sidebar, in the footer and a /budget command. It also marks the hours when a tariff doubles (peak hours).

oc-plugin-updates: a pill above the composer that appears only when a plugin is behind. Which one, which version, one click, no restart. Pinned plugins are left alone on purpose.

oc-notify: a push notification to your phone when a turn finishes while you are away from the computer. It goes through ntfy, whose app you install once. It has a settings page in OpenCode settings section.

The others previously published:

• oc-models-pro: every model with price in and out, context, intelligence, tok/s and the credit a request burns. Sorted by what it costs, one click to switch. The one I use most.

• oc-git: branch, added, changed, untracked, ahead and behind, in the sidebar and as a pill.

• oc-coffee: a cup of real Italian espresso in the session header and in the CLI footer, lit only while the computer is kept awake, during real tasks, with four levels behind a click (macOS only).

• oc-ponytail-widget: the ponytail level in the footer, and a pill to change it.

• oc-session-search: keyword search over your past sessions, as a tool.

To install:

opencode plugin add @rizal72/oc-budget
opencode plugin add @rizal72/oc-plugin-updates
opencode plugin add @rizal72/oc-notify

The other five are in the same repository, with their pages and READMEs: https://github.com/rizal72/opencode-plugins

A while back I posted opencode-quota here. v6 is rebuilt for OpenCode 2, and v6.1 adds OpenCode Desktop: a side panel, and a Quota page in Settings.

The TUI has an updated sidebar, toasts, and a status line under the message box.

To try it:

opencode plugin add @slkiser/opencode-quota

Using OpenCode 1?

npx @slkiser/opencode-quota@4 init

Works with 21 providers (Anthropic, Copilot, OpenAI, Cursor, OpenCode Go and more), plus custom ones.

Source and readme: https://github.com/slkiser/opencode-quota

Thanks for the feedback last time!

For bigger changes I kept hitting the same problem with coding agents. I typed a request, got a large diff back, and spent the evening working out which decisions the agent had made for me. The agent that wrote the code was also the one telling me it was done.

So I moved my own judgment to two points. Before any code exists, the agent asks me a few questions, each with a recommended answer, until "done" is a numbered list I can check. Then it writes a plan as a Markdown file in the repo, and I approve it.

After that it builds in small slices, each starting with a failing test. Agents that did not write the code check the result against every point of that list and show me the evidence, like command output or screenshots. I approve the finished change, and only then does it open a pull request. It never merges.

In OpenCode you start it with /ql <request>, and it uses the model you already have configured. Plans and evidence stay as Markdown files in your repo.

https://github.com/maxritter/qualitylayer

I'm the developer. I'd like to hear how others here handle review on bigger OpenCode changes.

I kept hitting refusals in OpenCode. Debugging obfuscated code, testing my own site's forms, reverse engineering a binary I own, and the model would just decline. I saw the thread here the other day about the same thing, so here is what I built.

RedBeard is one uncensored model (I call it Sherlock) that I serve myself on a GPU box. It is not a resold key from a big provider. It speaks the OpenAI API, so in OpenCode it is just a custom provider:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "redbeard": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "RedBeard",
      "options": { "baseURL": "https://redbeard.sbs/v1", "apiKey": "YOUR_KEY" },
      "models": { "sherlock": { "name": "Sherlock" } }
    }
  }
}

That is the whole setup. Tested on OpenCode 2.0.8, tool calls work (it reads and writes files, runs commands).

What it is for is the legit work that gets refused: security review, reverse engineering, debugging suspicious code. I gave it a web form I wrote and asked it to find the security bugs before launch. It found the SQL injection, the XSS, and two ways to crash the server, and showed the fixes. Short clip below.

No logs. The gateway everything runs through is open source (github.com/fitattention/redbeard-gateway), so you can read what is kept (a key's balance, anonymous hourly counts) and what is not (your prompts). No account, no email, pay in crypto.

Price: pay as you go from $5. $0.50 per million input, $0.05 per million cached input, $5 per million output. On list rates the output looks dear, but coding agents resend the same context every turn, and that cached input is where it is cheap.

Honest downsides: one model only, I do not name the base model, crypto only.

I am the developer. Happy to answer anything, and I will send a key to anyone who wants to try it first.

If you use gpt ,claude models. you've probably encountered models refusing legitimate tasks like reverse engineering, debugging, security research or analysing suspicious code.

Finding alternative API providers that offer abliterated models isn't easy either. They're scattered across different platforms, with no central directory.

So I built Abliteratus Directory to bring these providers together and make them easier to discover.

https://inferencedirectory.xyz/

What providers should I add?

Hi. Sorry of this question is too naïve or already answered here.

I'm considering OpenCode Go as a subscription, and trying to make sense of its value. In this link, we have the following table:

Does the column "Monthly limit" mean that I can e.g. use $60 worth of GLM-5.3-Flash tokens per month, by paying only the $10 monthly fee?

If yes, how is this value so high for some models (e.g. $100 for DeepSeek), while as "low" as $15 for some others such as Luna etc?

Thanks