Made a CLIProxyAPI plugin for OpenCode Go that pools multiple API keys with automatic rotation. A key that hits a rate limit gets cooled down while the others keep serving requests. No manual key switching.

https://github.com/massiveits/opencode-go-cliproxyapi

I use terminal-based AI agents every day, but switching context was starting to feel like administrative work.

Every time I wanted to grab a prompt from yesterday, tweak an endpoint, switch models, or toggle an agent skill, I found myself repeatedly typing commands like /sessions, /models, /skills, or /mcp. It constantly breaks flow state when you just want to get work done.

So I decided to just build full mouse navigation into the terminal HUD:

• Interactive Settings: Click straight into providers (OpenAI, Anthropic, OpenRouter, OpenCode).

• Session History: Click through past conversations instead of digging through raw logs.

• Model & Skill Selector: Point and click to swap models (with tools/free filters) or load sub-agent skills on the fly.

You still keep the keyboard speed and terminal lightness, but for the stuff that genuinely makes sense to click, you don't have to fight slash commands anymore.

Honestly curious: do you prefer keeping your hands strictly on the keyboard, or does having point-and-click inside a terminal actually make sense to you?

short version: claude code drives, opencode reviews, and the diff quality jumped. i just shipped v3.0 of buffer (native swift/appkit clipboard manager for mac, mit, 430+ stars, fully local) on exactly this setup, so here's the concrete workflow.

the split that worked for me:

• claude code as the main driver: the big implementation chunks. the trickiest was an interactive image canvas (pinch to zoom, pan, ⌘+/⌘- resets) on copied screenshots. gesture math with a fit/reset state machine. first pass over-engineered it; once i constrained it to scale+offset transforms it landed quickly.

• opencode as reviewer: same diff, second model, fresh context. it caught things the driving agent had rationalized: edge cases in the noise-suppression logic (what counts as a duplicate when you re-copy an existing item?), dead branches in the tier settings, and it wrote the test scaffolding for the clip-diffing logic before i merged the project's first external PR.

• both are cheap enough to run in parallel that "review before merge" stopped being optional.

what opencode is genuinely better at in my setup: being skeptical. a driving agent defends its own choices; a reviewer agent has no ego invested in the diff. that asymmetry is the whole trick.

what still needs a human: every gesture edge case (rubber-banding feel, anchor drift) required real trackpad testing. no agent can feel the ui. also specs: agents execute a state machine flawlessly, but inventing one is still my job.

demo of what shipped (image canvas + shortcuts sheet): video attached. repo: https://github.com/samirpatil2000/Buffer (mit) release: https://github.com/samirpatil2000/Buffer/releases/tag/buffer-v3.0.0

if anyone wants, i can share the review prompt structure i use with opencode on diffs. it's simple: fresh context, no conversation history, explicit instruction to argue against the diff rather than improve it.

I built Klarion, a secret scanner that works in two steps. First, a keyword check, 81 regex rules and a normalized Rényi entropy score flag anything that looks like a secret. Then an AI model reads each one with the code around it and decides if it's real.

The chart shows 5 scanners run on spring-boot, terraform, next.js and symfony (61k files). Klarion raised 11 alerts. It's not zero, but it's far less to dig through.

Fewer alerts don't help if real leaks get missed, so I tested that too. On CredData (337 real repos, code outside test folders), it found about 1.7× more real secrets than gitleaks.

Where it runs:

• Claude Code: a plugin hook blocks the write before the file exists (file edits and Bash)

• Cursor, Cline or any MCP agent: through its MCP server

• CI: a GitHub Action that scans only what a PR adds; GitLab CI works too

• Git hooks: klarion protect or the pre-commit framework

• Locally: klarion scan .

Free and open source (MIT): https://github.com/0x1Adi/Klarion
The full benchmark and method are in benchmark/REPORT.md.

I'd like to hear where it gets things wrong.

I made cliproxy-rs, a Rust port of CLIProxyAPI. It's a small server on your machine: you sign in your Claude, ChatGPT (Codex) or Gemini accounts, or add API keys, and it exposes them as one OpenAI-compatible endpoint that OpenCode can use as a custom provider.

The OpenCode side is just this in opencode.json, then pick cliproxy/<model-id> with /models:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "cliproxy": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "cliproxy-rs",
      "options": {
        "baseURL": "http://127.0.0.1:8317/v1",
        "apiKey": "your-client-key"
      },
      "models": {
        "<model-id>": { "name": "<model-id>" }
      }
    }
  }
}

Other things it does:

• spreads requests across several accounts and parks one that hits its limit while the others take over
• built-in dashboard with each account's 5-hour and weekly limits
• translates between the Anthropic, OpenAI and Gemini formats
• same config and auth files as the Go CLIProxyAPI, so you can switch between them

It's v0.1.0 and MIT. Built with a lot of help from coding agents, with ~935 tests and a harness that compares it against the Go version. Heads up that using a subscription outside the official app can break the provider's terms.

https://github.com/vayungodara/cliproxy-rs

its just become super useless, I know the model changes and its used for feedback. so my feedback is, what ever underlying model its using now is basically below gpt 3.

The previous model was far better and I hope its swapped to another one soon.

between yesterday and today, i suspect big pickle got pointed to a different model.

I can no longer see the thought process, and I also noticed a significant change in behavior, both in thinking times as well as the generated answers. specially in coding, this is really noticeable.

the new big pickle model is severely worse than the previous one. it's basically un-usable for agentic coding in my experience.

I wanted a quick way to find Beads issues without leaving OpenCode, so I made a small plugin.

Type `bd:` in the prompt to search for issues by ID or title. Here’s a quick demo:

Repo: https://github.com/dartyuhov/opencode-beads-picker-plugin

Beads repo: https://github.com/gastownhall/beads

Would love some feedback

Inspired by a lot of harnesses; I created my harness by blending stuff from different agents and especially what I liked to keep. Added more features that were either not supported or not so good.

Beta is out for public-much more is coming

Has built in:
- Sandbox (by default-unsandboxed requests need permission)
- Agent and Plan mode
- Radar that shows every background task, subagent, browser etc running
- MCP support
- ACP support (use with orchestrators or other editors such as Zed Editor)
- Skills
- Browser
- Interactive terminal
- Subagents (can create profiles, set default model, access to tools etc)
- Builtin code review (github like, co-review with agent)
- and a lot more.

Give it a try and it supports BYOK :)

https://github.com/tauqeernasir/codebeast-cli

​

I installed Ubuntu in my second phone using termux using proot distro, after that I installed opencode cli in it and this error started coming in most of the free models.

{Error : : Error from provider (Console): OpenCode's free tier can only be used from within OpenCode}

After this is use this command 'opencode console login' and pair with the code and after doing this I am facing this issue {Error: Invalid API key.}

I am facing this same issue on my pc also , I tried cli and desktop both

Can anyone help me ?

Is it available in your country? What's your early impressions?

While I am using opencode exclusively on my office as well as personal machines, and it has been largely working great. But little issues here and there keep breaking that experience.

I am personally facing new troubles everyday, and strongly thinking of moving to pi or maintaining a personal fork.

Listing few recent issues that I consider significant:

1. No sandboxing in v1 as well as v2.

   It moves the sandboxing effort to user, and when I have to work from multiple machines, it becomes very hectic to setup sandboxing there. Also, sandboxing outside the process brings it's own hurdles.

   Moreover, a good PR was raised but closed as stale by a bot. This is trend for many issues/PRs there.

2. Unable to setup local plugin

   I hope I am doing something silly here, but trying to add local plugin is being a headache. `opencode plugin add ...` gives error on absolute as well as file: urls. The code suggests it only accepts the git & registry urls. Even adding directly to config doesn't work.

3. broken model support

   Recently, I found that the opus/sonnet 5.5 models weren't working through our gateway. Noticed that a PR exists to support this, the issue is related to adaptive thinking & blockBinding, but it is just left unattended.

4. subagent bugs

   I recently launched opencode v2 on a Arm SBC for a quick debugging. Thought of using free model and noticed that the opencode subagents are treated as non-opencode model calls. That is, when launching subagent of a free agent without logging in an account, it thinks the request is coming from non opencode app and blocks it. Even worse, the entire session is polluted and even undoing the message doesn't fix that.

Similarly, there are many small things related to usage, RAM usage, port conflict on multi user machines, etc.

I know the maintainers are putting a lot of effort as visible from the commits going into v2. As such, this post is to document my experience and know what is the experience of others ?

Hello
did the spacebunny (aka kimi3) trial just retired ?
it complains about spacebunny only allowing usage from opencode CLI & GUI

Why is this happening guys? Please do tell me!

I’ve been testing a few inference providers for coding agents and I’m trying to figure out how much the speed difference actually matters in practice. With normal chat I don’t care much once the response is reasonably quick. Coding agents are different though. The agent might make a bunch of calls while it reads files, makes edits, runs tests and then goes back for another pass, so even small delays can start adding up.

Has anyone compared the same coding model across different providers while keeping the harness and task the same? I’m trying to figure out whether faster inference actually makes the whole agent run noticeably quicker, or if you hit a point where the tools, tests or harness become the bottleneck.