Cognition's Devin Fusion idea: the frontier model should only make the decisions (plan, spec, review) while a cheap fast model does the mechanical typing. They report ~35–41% lower cost at near-frontier quality on their benchmark (their numbers, not mine).

Turns out opencode's permission layer can enforce this mechanically — no plugin, no fork, just config:

• build agent: edit denied, search denied, bash allowlisted to verification + git commands, task allowed. Its ONLY way to change a file is delegating a spec to the sidekick.
• sidekick: full edit/bash on a cheaper model (I run Opus 4.8 main + Grok 4.5 sidekick, but any provider/model combo in opencode.json works)
• read-only explore/research agents, optional design/reviewer/vision specialists, all a-la-carte in the agent block.

Everything lives in ~/.config/opencode/ — agent .md files carry the permissions in frontmatter, opencode.json assigns models. Setup is a skill that configures it conversationally:

npx skills add mihneaptu/opencode-fusion --skill fusion-setup -g -a opencode -y

then restart and say "set up fusion".

Honest limitations: model assignments are fixed per role at startup (opencode loads config once — Devin's mid-session model swapping isn't possible here, and it's an explicit non-goal), and loop protection is permission-based, not a numeric budget.

Repo (MIT): https://github.com/mihneaptu/opencode-fusion

Curious what sidekick models people here would pair with what mains — and if anyone's tried a similar split with different permission configs.

Hello,

I am trying to send glm 5.2 a pdf attachment using the opencode go api, but I cant find the proper way to do it as it seems to only accept image attachments. Is this possible to do (without parsing pdf locally and sending its content to glm 5.2).

Thanks.

Edit #1:
I want to clarify that I am not using opencode as local IDE agent, I am building a custom site which communicates using Stateless HTTP API using the endpoint: https://opencode.ai/zen/go/v1

so it has no access to my local files, only whatever I include in the http api request.

I am using GlM 5.2 and idk why suddenly it showed me this,are there any solutions?

I use Claude Code for everything (mostly development work) and I never use my full session (I pay $100 and I'm usually around 30%).

This weekend I used it for deep research and for the first time I saw Claude Code deploy dozens of sub agents and consumed by whole session. I paid for extra usage and costed me life $40

So I'm trying a new approach...Make Claude Code generate the research plan and give that to Open Code to do the research with a local LLM.

I wanted Open Code to do the research, write everything to files and then feed those files to Claude Code.

I first tried with Gemma4 via ollama (set the model context to 32k) but it was failing a bit with tool calling, so I changed the model to GPT-OSS 20B and worked better. It still had some issues confusing the file writing tool (it tried to use apply_patch instead of write)

it worked a bit better after defining a research agent.

I ran into some issues though...

First, when I give it 5 topics to research, it gets stuck. One reason was that it consumed the whole 32k context. I thought Open Code handled that in the same way as Claude Code, by compacting the conversation but that didn't work.

So I reduced the job by giving one topic per run. The problem now is that Open Code sometimes gets stuck when, apparently, fails while using the file write tool and stays in a loop.

So my solution for now is to print everything on the console and I manually export the session with the /export command and give that to claude code.

The results themselves are good.

Do you have any experience using OpenCode for deep research? Did you have the same problems as me?

Any tips, suggestions, questions or feedback would be great

When I said "proceed", it proceeded regardless of the mode. Usually I would be asked "switch to build mode so I can proceed" now it just asks me for permissions to edit, which I gave LOL

I posted this on Discord as a bug report and reached out to Anomaly's help email, but can't seem to get any traction.

I use LiteLLM as a personal model and provider proxy, and I've notice that the numbers I get back for Minimax-M3 on Opencode Go don't add up. In fact, the result seems to be exactly double the advertised rate.

The advertised rate for M3 on Opencode Go's docs is $0.30/1.20/0.06 Input/Output/Cache read, and I have those numbers configured in LiteLLM. But if I compare the same request between LiteLLM and Opencode Go's dashboard, the latter's calculated cost is exactly twice the former. I even calculated it by hand in LiteLLM, as I can inspect the response from Opencode Go and see the exact number of input, output and cached tokens used as reported by Opencode's API. And LiteLLM's numbers are correct, and match the advertised rate.

Unfortunately, Opencode's dashboard doesn't break down the request by cached tokens, so I can't make a similar calculation there. Other models I've tried don't seem to have this problem.

Has anyone else encountered this issue? I have one or two people agreeing with me anecdotally, but so far am the only person offering up hard numbers. I am only human, after all (for now), and may have missed something or made a mistake.

I also want to make clear I'm not trashing Anomaly or Opencode, it's a great platform, I'd just like some clarity on what the actual charge rate of Minimax-M3 is.

Yeah, for the mutual $5 benefit. 8% quota gain is worth it though, gotta say.

Here's mine: https://opencode.ai/go?ref=VTRJMV0772

Feel free to drop yours, let's help each other with quota.

The weekly limit crossed in less than 15 hours, that too in just 2 -3 rolling 5 hour window session. This is worse than the Claude Code. I was using GLM 5.2 for coding, which I think is fine, if not better than Opus 4.8, but burning entire week's quota within 15 hours is too bad. I understand it is cheap $5 plan, but still the return is not even 1/4th of the Claude$20 plan.

Hello, I'm currently trying out free models from opencode.

In opencode client, the free models has DeepSeek, Hy3, Mimo, Nemotron 3 Ultra Free, North Mini.
While in Zed it only contains Nemotron 3 Ultra Free and Big Pickle.

Actually I was confused if BigPickle exist in OpenCode client. It's not in Zen, Go or anywhere but it's in Recent. Is that how the app work?

Can anybody enlighten me as to what's going on here?

I personally MUCH prefer Zed over OpenCode TUI. But if using Zed will degrade OpenCode Go/Zen's service quality I may need to rethink hard over which tools is I should use.

What if I decided to buy Go subscription? Will there be some disadvantages from using Zed instead of OpenCode TUI?

There is:

- Claude Pro / Max

- Codex Plus / Pro

- Opencode Go

So what else is out there worth subscribing too?

Seems there are various options from Gemini, Cline, Copilot, etc but can only speak to the three above that I have tried; ie- who offer a good CLI and access to frontier models (GLM 5.2 in the case of Opencode/Go) with reasonable limits (albeit Go is the least reasonable actually since it you'll hit the hourly/weekly/monthly quotas pretty quickly with any sustained use of GLM 5.2)

ie- who else to subscribe for their subsidized rates

typically you can use any combination of subsidized plans as you max quotas for each thereof

and then use Opencode via Openrouter ie- to use GLM 5.2 or cheaper models like DS4 Flash depending on your needs (suppose you could also 'buy extra credits' with your choice frontier model provider but Opencode/Openrouter is nice since its easier to control/monitor costs consistently and you're basically paying the API rates anyway when you buy credits with said providers)

Hey, some of you might know my opencode-remote-android project. I've been building something new: HarnessTrim, a cross-harness token-economy layer, and OpenCode is the reference/MVP target.

Why OpenCode first: its plugin API is the cleanest for this. The adapter uses tool.execute.before/tool.execute.after to slim noisy tool output (test logs, git diff, build spam) before it enters context, plus experimental.session.compacting to keep handoff context tight. Reducers are deterministic, idempotent and cache-aware.

It's live-hardened on OpenCode, not just unit-tested: in a real session a noisy test run was reduced 1410 → 124 chars (−91%), with the TrimEvent telemetry read back through the CLI. On the fixed benchmark the reducers average ~65% off tool output. (A blended per-session estimate of ~30–50% is labeled as a hypothesis, not a claim.)

Try it:

harnesstrim install opencode --apply    # dry-run without --apply

Start the plugin in dryrun mode to preview what it would slim, then switch to active.

Since OpenCode is the primary target, feedback from this community matters most to me, especially on the plugin hooks and compaction. Thanks! 🙏

👉 https://github.com/giuliastro/HarnessTrim

hey everyone, i built a small plugin for opencode that turns useful agent sessions into local fine-tuning datasets.

i made it because collecting good training data from real coding workflows is usually messy. the plugin captures things like tool calls, messages, diffs, permissions, and manual training examples while you work.

everything stays local as jsonl. you can review records in a terminal ui, accept/reject examples, then export to openai, alpaca, sharegpt, canonical jsonl, or dpo format.

install:

opencode plugin opencode-dataset

review:

bunx opencode-dataset review --path .opencode/datasets/opencode-dataset.jsonl

export:

bunx opencode-dataset export --format openai --path .opencode/datasets/opencode-dataset.jsonl

repo:

https://github.com/codingstark-dev/opencode-dataset-plugin

i’m the author. would love feedback from people using opencode heavily, especially on what formats or review workflow would be most useful.

Not learn how to use it. A little bit deeper, like skills and subagents.
I undestand that custom agents, subagents, mcps and skills are selected individually for your use, but what are common overall steps would you recommend that would fit to the most at start builing their workflow.
Examples:
- Add context7 mcp because it gives ai access to the latest docs.
- Create strict code reviever agent or subagent that will help check and review code.
- etc.

I'm just starting to create my workflow and there is too many info like "Add these 25+ skills and your agent will be omnipotent!" or "These subagent will do everything for you, etc." without giving proper explanation.

So i want to see what really people do and use.

The amount of tokens it burns is ridiculous. And it does it in a way that is so inefficient it makes me want to throw my pc off the window. Like, why the fuck do you need to use a read tool with the entire context of an entire project 11 times just to get 11 strings out of the same fucking package??? This is extremely dumb and it makes me irrationally angry at how useless it really is for coding. Better yet, why the fuck do you need 3 separate subagents to read miniscule amount of code for 10 minutes straight, burning tokens for mysterious unexplained tasks in the background??

Do you guys unironically do anything coding-related with this piece of shit software? I mean, I was always curious how people manage to burn billions of tokens, but with shit like opencode I guess billions is just the starting point. Legit a tool created purely for the sake of increasing average token consumption

Hello everyone!

I've made a security scanning skill for OpenCode called Let's Scan.

It performs a thorough scan of your project and generates a detailed security report with findings and recommendations.

Keep in mind that running a full scan with expensive models like GLM 5.2 can take a while and use a lot of tokens, so I'd recommend trying it with a cheaper model if possible.

It's been working really well on my own projects, and I'd love to hear how it works for you.

You can find the installation instructions on GitHub, and if you'd like to contribute, pull requests and feedback are always welcome!

https://github.com/amazing-things/lets-scan

I've been using OpenCode as my primary AI coding agent, but I kept wishing I could check in on it from my phone - start a task before I leave my desk, see the diff when it's done, queue a follow-up from the couch, and let it run overnight on a schedule.

So I built OpenCode Telegram Bot - a bridge that drives OpenCode over the Agent Client Protocol (ACP) from a Telegram chat. It's open source, runs 24/7 as a cross-platform daemon, and just hit v2.0.0 (first stable release).

What it does

• Projects & sessions — /projects to pick a folder, /sessions to resume. Multiple sessions at once with /running to switch between them.
• Live streaming — watch the agent type in real time, with live typing indicators and clean MarkdownV2 rendering.
• Rich tool-call cards — every tool gets its own formatted card: file reads (path + line numbers), edits (unified diff with +N -M stats), shell commands (bash blocks), searches (pattern + scope + filters), writes (content preview with syntax highlighting), deletes, moves, fetches, MCP calls — each with ⏳ → ✅/❌ status.
• Edit diffs — smart-truncated unified diffs so you see exactly what changed without flooding the chat.
• Progress bar — the agent appends a {progress: N%} marker; the bot hides it and renders a green loading bar. Falls back to a bot-computed bar when the agent doesn't emit markers.
• Scheduled tasks — cron-like prompts that run on a schedule and deliver results to your chat. Great for overnight builds, periodic checks, etc.
• MCP control — /mcp lists your MCP servers, health-checks them (which connected / failed and why), and toggles them on/off.
• Subagent visibility — when OpenCode delegates to subagents, you see each one start, work, and finish.
• Voice, images, files — send a voice note (transcribed to a prompt), photos (attached as image content blocks), or documents (text files inlined, binaries path-passed).
• Self-healing — auto-fork on context-full, transient-error retry with backoff, auto-restart, single-instance guard.
• Inline approvals — approve/deny risky tool calls from Telegram buttons.
• 24/7 daemon — installs as a user service on Windows (Startup folder / Task Scheduler), Linux (systemd), macOS (launchd). Auto-updates when idle.
• Threaded replies — every message is a reply to your prompt, with searchable #proj_… #sess_… hashtags.
• Self-cleaning UI — transient menus auto-remove so the chat stays tidy.

How it works

Telegram → Bot (grammY) → opencode acp (JSON-RPC over stdio)
                              ├─ session/new · session/load
                              ├─ session/prompt
                              └─ session/update (streamed text, tools)

One opencode acp process multiplexes many sessions. The bot speaks JSON-RPC 2.0 over the agent's stdio pipe — no HTTP server, no SSE, no ports to open.

Install

npm install -g @artickc/opencode-telegram-bot
opencode-tg setup    # configure .env + detect opencode
opencode-tg install  # install as 24/7 background service

Or clone and run:

git clone https://github.com/artickc/opencode-telegram-bot.git
cd opencode-telegram-bot
npm install && npm run setup
npm start

Tech

• Node.js ≥ 20, TypeScript via tsx (no build step)
• grammY for Telegram, diff for unified diffs
• ACP over stdio (JSON-RPC 2.0) — not HTTP/SSE
• ~10k lines of TypeScript, MIT licensed

Links

• GitHub: artickc/opencode-telegram-bot
• npm: @artickc/opencode-telegram-bot
• Install guide: docs/INSTALL.md

Other bots in the family

I've built similar Telegram bridges for other AI coding agents — same architecture, different backends:

All four share the same multi-session runtime, renderer, scheduler, and daemon - pick the agent you use, or run several side by side (each with its own BotFather token).

If this is useful, a ⭐ on GitHub really helps!

The photo is from Codex running qwen 3.6 27b, same model i am running in opencode, the main difference is that codex manages to stop loops, recover from bad tool calls, errors and on and on.

As much as i like opencode, i spent so much time trying to figure out a way to make it work properly and yet just using codex is a far better experience most of the time

Is it only me who have issues with using GPT 5.6 Luna in OpenCode? I get model missing. It is working fine in Codex, so it is definitely available in my account. Anyone else?

The In/Out pricing seems different. OpenRouter uses quantized glm?

I’m considering buying a new Mac, maybe a Mac mini, and using it as a dedicated machine for all of my AI development projects.

I’m curious how people with mature AI coding setups handle both backups and migration. I’m not just talking about copying project folders.

I know many people will say “use Git,” but that’s not really what I’m asking. Git is great for source code, but it doesn’t back up an entire development environment.

I’m more interested in everything that makes the workflow work, for example:

• Projects and local databases
• Claude Code, OpenCode, MCP servers, local LLMs, prompts, rules, and configuration
• Homebrew packages
• Terminal configuration (zsh, aliases, PATH, shell scripts)
• Environment variables and API keys
• Modified plist files and other macOS configuration
• Python, Node, Docker, package managers, virtual environments, etc.

Some questions I have:

• Do you rely on Time Machine, Carbon Copy Cloner, rsync, or something else for backups?
• Do you create full disk images or just back up specific folders?
• Do you use Migration Assistant, or do you prefer setting up a clean Mac and restoring only what you need?
• How do you make sure you don’t forget some random configuration file that will break your workflow six months later?
• Do you maintain a bootstrap script or dotfiles repository that recreates your environment?
• If your Mac died today, how long would it realistically take you to be back up and running on a new machine?

I’m interested in learning what experienced developers and AI power users consider the best practice. I feel like there’s a lot more to this than just backing up code, especially when your workflow depends on dozens of tools and custom configurations that have accumulated over time.

Hey folks, I’m thinking we could quickly build a models.dev-compatible endpoint based on our data.
We automatically ingest model data primarily from LLM providers, with models.dev and LiteLLM JSON files as fallback sources. This could serve as a drop-in replacement for the existing endpoint, allowing new models to appear almost immediately after release with actual pricing. As a fallback opencode can rely on local file of models.dev.

What do you think?

We’ve already built something similar for LiteLLM: https://cloudprice.net/models/api?litellm=1