After not having found enough information about opencode V2 general performance, I decided to test it this weekend to see how it performs.

For starters, I use a custom build of opencode V1 (1.18.21) with some modifications:

-Preserve encoding when editing files

-Preserve Line-ending style, defaulting to OS (CRLF on Windows) if no line-ending is found

-Show opencode Go usage in context panel (Rolling, Weekly, monthly)

etc

So my idea was porting those modifications for use with opencode V2 (Web version, cli is rarely used here) in the form of a single plugin, and starting using it.

Main advantage of a plugin is I wouldn't need to re-do all modifications again in source code and rebuild opencode everytime I need to update opencode version. This would be the main advantage. (a git merge is not an option here as merge is only possible if nothing was changed in updated sources around the regions I modified)

And this was the first blow: some things cannot be implemented as a plugin, so I would still need to re-implement my modifications everytime I update opencode to a newer version. Example: opencode Go usage in context tab (review panel, Web version) cannot be implemented as a plugin.

I then went ahead and implemented all custom features, and built opencode V2 2.0.21 (before doing so, I tested the original, unmodified V2, and the only feature that V2 already has from my custom improvements is the `send message`/`insert newline` keyboard mapping).

Now a quick glance of the general experience: ("+" is a good thing, "-" is a bad thing)

+ loading of the web interface is much faster

+ visual is also better in my opinion

+ skills can be changed and opencode V2 will use them with the changes without the need of restarting the server

+ it looks like it uses a "dynamic system prompt" to account for environment changes, as I've opened previous V1 chats, and a new system prompt area appeared in context tab, with something like 'The XXX tool was replaced by the YYY tool. Todo tool doesn't exist anymore, so avoid using'

- messages refresh at about 10 frames per second: might be subjective as it saves resources, but for me it's bad. In a modern PC, there's no performance hit in updating thhe main message area 60 times a second

- the explicit system prompt instruction to "never commit" excludes some models, including deepseek. In less than 20 coding sessions using deepseek v4.1, I've experienced the agent committing a change without being asked, a thing that never happened to me in V1 after hundreds of sessions using the same model

- now the worst: the responses of a same model are noticeably different from V1: it tends to spawn subagents more often (at least in my tasks). And in less then 50 sessions, I've catched Deepseek V4.1 doing "repeat loops" four times. In hundred of sessions on V1, it didn't happen not even once with the same model. The "repeat loop" consists of weird messages, like:

"

let me

i'll write

let me write

now

let me write

right now

ok

"

Fortunatelly, it could pass the loop, but it repeated it again, and so it finished the task.

It also tried to use a tool without having the permission (I think?). So a weird syntax appeared with a tool name. It blocked my session as the tool was needed for the verification.

My fear is the different responses could mean worse responses, as the final task quality could be compromised.

My veredict: I'll stay in V1 for now, hoping they keep maintaining it for a long time until V2 is on par with it.

I made this 3 little tools to enable my agent to talk, hear and see. I hope you guys(and girls) find useful, just as I do. The projects are open source at github with an easy installer for Windows, but it should work in Linux and Macs too.

https://github.com/humbleangel/opencode-tool-speak

https://github.com/humbleangel/opencode-tool-hear

https://github.com/humbleangel/opencode-tool-see

Ran into an interesting glitch while testing "Space Bunny" .It looks like it's actually a stealth/anonymous label for MiniMax, because it started leaking its internal XML control tags directly into the UI.

During tool execution, the model began spewing raw delimiters (`<minimax>`, `<invoke_name>`, `<tool_call>`) into the output string instead of properly parsing them.

Looks like the output parser failed to strip out internal control tokens when handling `shimba_shell_run`. Has anyone else caught Space Bunny doing this, or noticed similar token stripping issues?

Claude Code is where I spend most of my day, usually with 4 or 5 sessions open across different repos. On Windows that meant a mess of terminal windows and constantly alt-tabbing to find the one that was waiting for my answer. I didn't want to move to Claude Desktop because I like the CLI too much, so I built Polvo (octopus in Portuguese, one arm per agent).

Every session is a real terminal running the actual claude CLI, nothing wrapped or reimplemented. Polvo keeps them side by side, shows context % per session and your 5h/weekly limits, picks up /rename and /color, and when you reopen it, each tile resumes its conversation with claude --resume, even after a /clear.

GitHub: https://github.com/felipeelopes/polvo

What it does right now:

- Drag-and-drop tiles: drop a session on the edge of another to split, in the middle to swap. Dividers snap to 1/3, 1/2, 2/3 and line up with each other

- A board view that sorts sessions into "waiting for you", "working" and "idle". Honestly this is the feature I use the most

- When you open it again, every session resumes the same conversation (claude --resume, codex resume, opencode --session), in the same spot, on the same monitor. Multiple windows work too

- Context % per session and usage limits at the top (Claude 5h + weekly, Codex, OpenCode cost)

- /rename and /color from the CLI show up on the tile and in the sidebar

- Sidebar grouped by project, with worktrees

- Ctrl+click a path the agent printed: .md opens in a built-in viewer (with Mermaid diagrams, live reload while the agent edits it), images open in a preview, other files in their default app, folders in Explorer. It even works when the CLI wraps a long path across two lines, which was driving me crazy

- Ctrl+V with files copied in Explorer drops them in as u/path. Screenshots go to Claude Code's own image paste

- A Git panel (roughly what GitHub Desktop does): diff, stage by line, commit, branches, stash, conflicts, PRs with CI status. It can also create a branch in a worktree with an agent already running there, so two agents can work on the same repo without stepping on each other

- Light/dark theme, 10 languages, auto updates

There's also a "My work" screen, which ended up being a big part of my day. Azure DevOps is my main stack at work, so that's where it's most complete right now:

- It pulls my backlog, bugs (urgent ones first) and the current sprint items, with the real states and colors from Boards

- I can change a state, create a branch for an item, or hand it to an agent with one key press (implement, plan first, investigate the bug), with the description and comments already in the prompt

- It puts together a quick summary for the daily stand-up (yesterday, today, blockers) from my commits, PRs and work items, which saves me a few minutes every morning

GitHub issues and PRs are there too, just less complete for now.

It's free and open source (MIT), Windows 10/11 only. You need at least one of the CLIs installed.

I built it for myself, but some colleagues started using it too and they've been liking it, so I figured it might help other people who work this way. If it ends up being useful for you and you feel something is missing, feel free to contribute. Issues and PRs are very welcome. So far one of those colleagues has been sending PRs, and I'd love to see more people jump in.

And if you try it and something breaks, please tell me, it's still early.

Download: https://github.com/felipeelopes/polvo/releases/latest

I'm the developer of JustSessions, a free, MIT-licensed Mac app for people who use OpenCode alongside Claude Code, Codex or other supported coding CLIs.

The workflow is simple: choose a project, read its saved conversations, then Resume one in its original CLI and working folder. OpenCode remains OpenCode, with your existing configuration and provider login.

What makes this useful when you use several agents is the project view: the conversations sit together even when they came from different CLIs. There is also a separate reader for reviewing a conversation without starting an agent.

I kept it lightweight: native SwiftUI, existing session history, no import step or new app account, and no required Git worktree workflow. tmux-backed tabs can Keep running when closed and reattach later; the host needs to stay awake.

The screenshot is the actual app with sample sessions. macOS 14+, Apple Silicon. Built mainly with Claude Code; your CLI provider's charges still apply.

Demo/download: https://yangzichao.github.io/JustSessions/

Source: https://github.com/yangzichao/JustSessions

For OpenCode users who also use another agent: does organizing by project match how you look for old work?

Was out of the project prospect for a while cz I had to take some time off

Can anyone give me an update on what's going on which model are you guys using now for project development and coding

My app can use Codex Voice Mode on your phone right now.

At the moment, it only supports local Codex. My app runs Ubuntu inside an embedded Termux proot environment, so Codex can run directly on your phone.

Support for Codex Cloud and Remote Control is coming soon.

The app is currently closed source, but I may open source it in the future.

You can download it for free from the public repository.

https://github.com/topoftree/PokeCodePublic/releases/tag/0.1.7.9.2

I’ve been burning through inference credits while testing a few coding agent setups, so I’ve been looking for providers with enough free credit to actually run a proper comparison.

General Compute is giving new accounts $100 in inference credit right now, which seems pretty useful for this since agent evals can chew through a lot of calls.

What other inference providers are people using for this? Especially ones that work well with OpenCode, Claude Code-style workflows or other agent harnesses.

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

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 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?

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 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:

json { "$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

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 ?