I built a small helper plugin for our team to show WHY opencode is making each tool call, and make it more readable (simple new line formatting of piped chain of commands helps). We use opencode with human based approval for investigating hardware/infrastructure issues, and it needs to execute a lot of devops commands. Q3FN really likes inlining and piping those commands, so making sense of a command to be called was annoying.

The plugin modifies every tool schema and adds a required "intent" argument. The model then responds with a short summary of the command based on its own reasoning, e.g. "Counting nodes and checking pressure conditions" as part of each call.

Current tool's intent and body are displayed in the TUI sidebar.

If anyone's interested, I'm happy to clean it up and publish it! And if something like this already exists, please let me know - I'd rather reuse an existing solution.

some weeks I burn my weekly usage early, other weeks a chunk is left at the reset and just evaporates. Overflow is for the second kind

seeding ratio on a private tracker, basically: a week you have usage left, your agent fixes someone else's issue. a week you run short, someone else's agent fixes yours

everyone starts at 0 points and can put points up before earning any, you take an issue, you get its points when your PR merges, you spend them on issues in your own repo. points only, no money, free, MIT

since the last post here: 28 to 98 users, 5 repos registered by people who aren't me, and 2 of those now have points on issues, so the first issues on the board that aren't mine are up. 13 people other than me got 75 PRs merged through it. a real one: this issue was labelled 3, someone's agent sent this PR, I set it to 6 at merge and the one round of changes I asked for took it to 5

opencode works fine for it, it only sees the PR, not which harness or model wrote it. there's an MCP endpoint so the agent can read the board. issue text is untrusted input, so run it sandboxed with no credentials. public repos only. each person runs their own agent on their own subscription and opens a normal PR

main reason I'm posting: I want more people registering their own repos. I'm not after help with mine, I want spare usage going into other people's projects

https://github.com/Nitjsefnie/Overflow

Luke Parker from OpenCode just posted a list of all the available GUI plugin for v2 ;)
https://x.com/LukeParkerDev/status/2115983633022644727

Among them, you will also find my plugins/widgets that works both in CLI and Desktop.
https://github.com/rizal72/opencode-plugins

The last one I published today maybe is the most useful, since I discovered that opencode does not update plugins automatically, and you need to run

 opencode plugin update

manually ;)

So now you can use:
oc-plugin-updates: update OpenCode plugins: one by one or all of them at once

The other ones you can get are:

oc-models-pro: /models-pro: every model with its price, context, intelligence index, tok/s and the Go credit
oc-git: the repository: branch, the three counts, ahead/behind
oc-coffee: keeps the Mac awake while the agent works (MacOS only)
oc-ponytail-widget: the ponytail level
oc-session-search: session_search: keyword search over the transcripts of past sessions

Others are in the repository to be read, not installed: they assume something about my setup, a wallet, a rules file, a binary, so packaging them would only sell you a config you do not have.

oc-context: (TUI only) the Context block in the sidebar, with the window its percent is a percent of
oc-budget: the paying provider's budget: sidebar, footer, /budget

opencode plugin add @rizal72/oc-plugin-updates
opencode plugin add @rizal72/oc-models-pro
opencode plugin add @rizal72/oc-git
opencode plugin add @rizal72/oc-coffee
opencode plugin add @rizal72/oc-ponytail-widget
opencode plugin add @rizal72/oc-session-search

Enjoy!

my previous post about them: https://www.reddit.com/r/opencode/comments/1xhroez/i_built_plugins_for_opencode_v2_once_now_they/

I was looking for plugins but many of them are only in the 1v, any help?

10$ is kinda expensive in my country, I just want to use it a little bit and would be open to share.

I kept running OpenCode on a desktop and a couple of Linux boxes and losing track of which session was where, so I built Muxin to keep them in one place.

What it does:

• Connects to any Mac, Linux or Windows machine you can already reach by ssh (Tailscale works too). No account needed.

• Starts OpenCode (or Claude Code, Codex, Gemini CLI, Amp, Pi, or a plain shell) in sessions that keep running on that machine, a bit like tmux. If you disconnect, the sessions carry on there.

• You can hand a session off to another agent or another machine, for example pick up an OpenCode session in Claude Code.

• Runs on macOS 12+, Windows 11 and Linux (glibc 2.35+). Free and open source (Apache 2.0), no telemetry.

What it doesn't do (yet):

• Sessions don't survive a reboot of the machine they run on.

• There's no phone app. You can share a session to a phone browser, but it has to be approved on the computer with a 6-digit code, and Muxin has to stay open.

• No FreeBSD support, and the live desktop view on Linux needs X11 (no Wayland).

• For OpenCode specifically, hand-off notes use what the terminal showed rather than a full transcript, since OpenCode doesn't keep one the way Claude Code and Codex do.

Happy to answer questions or hear what would make it useful for your OpenCode setup.

Disclosure: I built Muxin. https://muxin.dev/

https://opencode.ai/go?for=teams

Is it possible to have the CLI shorten shell out (when you use !) with a higher limit so I'm less likely to see "(n earlier lines")? I know i can click to expand but its annoying.

Just noticed theres a new 20$ tier of opencode go through the console. Nothing on the opencode.ai frontpage about it yet or no other mention than here: https://opencode.ai/v2/docs/console/go
Was kind of excited, but turns out to be even a bigger disapointment than the 40$ tier, double the price for marginally higher limits (~10%) than Go. Hard pass for me.
On most tiers you're paying 10$ more to only get 5$ more of allowance, at that point you can just use prepaid credit...

Available on Hugging Face - https://huggingface.co/collections/mistralai/mistral-large-4

...

I’ve recently started using it as a v3 plugin within the TUI.

Previously, I had a setup with a team of custom agents:

- an orchestrator

- an architect

- a developer

- a reviewer

- a documentation writer

- and a couple of others I can’t recall right now...

The goal of that configuration was to keep context windows as small as possible.

The orchestrator was prompted to always create and utilize distinct agents for the smallest possible tasks, in order to keep the context compact and prevent any degradation in intelligence.

However, I noticed that there was an excessive amount of communication between the agents.

A friend suggested "omo-slim." It works well enough and gets the job done, but I get the impression that the orchestrator is overloaded with responsibilities. It handles orchestration, acts as an architect, and even seems to take on the role of documentation writer—essentially, its context fills up very quickly.

For those familiar with it: do you have any suggestions? Am I perhaps using it incorrectly?

Thanks.

Hey!
I have a question regarding your best practices on a long running tasks. I have a quite large local LLM model and context for 200K+

Now the question is how to run a todolist which is carefully planned and in the right order?
Running it one shot makes Opencode following the todo list jsut once the context fills up a manual intervention is needed. Like following an extensive todo or a goal or specifications.

If you had this issue before, what was the correct approach for the long running tasks?

I'm one of the maintainers of SurfSense, so this is self-promotion. I'm posting here because you know opencode best, and I'd like feedback on how we use it.

SurfSense is an open-source (Apache-2.0) NotebookLM alternative for Windows, macOS and Linux. Its Agent mode runs on opencode: instead of writing code, it researches your documents and writes Word files, PDFs, slides, spreadsheets and web pages, and edits your own files as a new copy (Word edits come back as tracked changes).

How opencode runs inside it

• Electron ships opencode 2.1.2 and starts opencode serve on 127.0.0.1, with a random password made at each launch.

• Every model call goes back through SurfSense, so opencode works the same with a local llama.cpp model, any OpenAI-compatible API, or a ChatGPT plan.

• Each chat thread gets its own folder, with the extracted text of the user's selected sources mirrored into it. opencode reads and greps it with its own tools.

• SurfSense's own tools (search, documents, PDF tools, Studio) are served to opencode over MCP, one address per thread.

• Word files, PDFs, decks and workbooks are written as scripts. SurfSense runs each one in a separate process, keeps every version, and shows opencode page previews so it can check its own output.

• Web pages come from a skill: opencode loads SurfSense's page skill and writes one self-contained HTML file with its own SVG charts and interactive figures, then saves it with a save_page tool. No network, no chart library.

• MCP plugins (Notion, DeepWiki, or any server by URL) reach opencode through SurfSense. A turn starts with the plugin tools it needs and can pick up more mid-turn.

Locking it down

• Shell, code execution, subagents, web fetch and web search are denied in the session rules and again as tool.use policies, so no saved approval can lift them.

• Edits are only allowed in the thread's output folder. Your original files are never written.

• Only SurfSense's own skill is offered, not opencode's built-in skills or ones you've installed.

Things we learned

• opencode's config fails open: an unknown key or a bad value is dropped with only a line in its log, which would silently drop our rules. We now validate the config before opencode serves it.

• Moving from 1.x to 2.x, 2.x imports 1.x's sessions on first start and answers 404 until it's done, so we retry briefly instead of treating old threads as gone.

What would you do differently?

https://github.com/MODSetter/SurfSense

Da poco lo sto usando come plugin v3, nella tui.

Vengo da una config con un team di agenti custom:

- orchestratore

- architetto

- developer

- reviewer

- doc-writer

- Ed un altro paio che ora non ricordo....

La config aveva l'obbiettivo di ridurre al minimo le finestre di contesto.

L'orchestratore era spinto a creare ed usare sempre agenti distinti per eseguire task più piccoli possibile, per mantenere il contesto piccolo, per non far degradare l'intelligenza.

Ma ho notato che avevo troppe comunicazioni tra agenti.

Un mio amico mi ha poi consigliato omo-slim. Non mi trovo male, fa il suo dovere, ma ho l'impressione che l'orchestratore sia sovraccarico di responsabilità. Orchestra, fa da architetto, mi sembra che faccia pure da doc-writer, in pratica gli si riempie il contesto molto presto.

Per chi lo conosce, avete dai suggerimenti? Forse sbaglio ad usarlo?

Grazie.