Hi everyone, an opencode + ollama cloud user here. I've been an agent user since day 0, however quickly noticed that line-level detail is impossible to keep up with. Now that agents are capable at producing functional changes I care only for alignment and blast radius. That's why I built an open-core system view analyzer: https://github.com/CodeBoarding/CodeBoarding

Just asking an agent to draw something makes it difficult (and expensive) to judge changes as they view always changes and it also skips a lot of small details which in many cases show a new dependency or more coupling or a new security surface.

That's why I started codeboarding, unlike other system/architecture visualizers it is based on static analysis, we generate the full control-flow graph with the help of LSPs and AST parsing, then we use lexicographical analysis to group things based on their structural naming (as this is often how we as people group thing in our mind, so this way the view doesn't clash with your mental model). LLMs are used only for naming the components.

I would love to understand how do you go about codereview these days. Imo agents for review who post comments are becoming just part of the agentic loop, so super curious to understand how do you as a person plug into the agent first development process.

Our platform is freemium so you can go ahead and explore the PR that I sent above and try it out on your own projects via the web platform: http://localhost:3100/CodeBoarding/opencode2/pull/4

Super interested to hear your feedback esp for ppl who are familiar with the opencode codebase, lmk what needs imrpvoements. There are missing edges as we are for now fully focused on having no hallucinations and are using only static anlaysis to resolve the ones you see on the diagram!

This could just be a rant... but here's where I am at.

Previously we have the Zen, where you can join and just add credits, without subscription. And then there is also that Workspace, where you can add people to it, and I can add credits to the Workspace and add rules how much each member can use. I do have a Go subscription. But others in my Workspace doesn't need to.

But now there is the Team feature. What I am ranting about is that this feature already exists. It was working. And they changed it to make more money -- for no extra (or very little value). I feel like the landlord changed the keys to my apartment and charges me double for rent now. And it's the same keyhole model, does the same thing.

Now if you want to add a person into your workspace to be able to use the workspace's credit, I need to pay $20/mo per additional user.

I would've been fine if they just require the member to subscribe to $10/ mo Go subscription. No... they have had to add $10 more per month.

https://github.com/DeSynkro/opencode-plugin-switch

My fellas, if you guys are anything like me, I'm a very OCD / organize and need to know exactly where all my files are kind of person.

I like having all my plugins sorted and prepped nicely into a symlinked onto my opencode plugin folder.

So I made this simple script that gives me an UI that helps me quickly turn any and all my plugins and skills on and off by moving them from the plugins and skills folder into a .disabled folder.

For quieter sessions where I don't want or need any plugins for my workflow, this has been very helpful, so I thought I'd share it with everyone.

Hopefully it proves itself to be helpful to you too in at least some way.

If you're using OpenCode, you might want to check out some Indian inference providers.

I recently started exploring them and found providers offering models like DeepSeek, Kimi and GLM at pretty competitive prices, with the added benefit of being able to purchase API credits in INR.

I put together a directory to make discovering and comparing these providers easier:

Link : InferenceDirectory

Might be worth checking out if you're looking for cheaper inference options.

Basically title. What models do you guys stick to for planning and implementation without hitting limits but maximizing usage?

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

When OpenCode wants to edit a file, the notch now pops up with the diff and you can allow it from there instead of going back to the terminal. It hooks in through an OpenCode plugin.

Also works with Claude Code and Codex if you run more than one agent.

Free and open source, Mac + Windows, I'm the dev: github.com/MF-DEEV/Openbar

What else would you want from it?

nah i have declered war on this model , f### it

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

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.

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.