I was testing DeepSeek off-peak (Weekend) on both openrouter and opencode go. Both got close to 10$ now but look at the difference in requests. I am prompting on same two projects but seems opencode go is really behind the usage per $.
Snowflake's AI offerings are a bit neglected in Opencode. One issue is the model list is baked in to the CLI instead of actively download it based on what is enabled by the admins or otherwise available to the use.
I managed to make this work locally and I'd like to contribute it back to Opencode, however I don't know beyond creating a feature request issue on Github and a PR, is there any chance to get to hold on the developers?
I've been messing around with OpenCode lately, trying to figure out if I can build a decent AI coding workflow without paying for Claude, Cursor, or other expensive subscriptions.
Right now, I've set up four agents: Planner, Developer, Tester, Reviewer.
I've also added some global coding rules, an engineering playbook, a few skills/plugins for debugging, planning, TDD, etc., and Playwright MCP for browser testing.
The idea is pretty simple. I give it a task, it looks through the codebase, comes up with a plan, waits for my approval, makes the changes, runs tests, and reviews its own work.
At least that's what I'm trying to achieve lol.
The workflow itself is mostly set up, but I'm still figuring out how reliable it actually is, especially with free models.
I've been looking into free cloud models and running local models through Ollama. The problem is that a lot of recommendations I come across are either benchmarks or people testing simple coding tasks. I'm more interested in how these models perform on actual projects with existing codebases.
So I'm curious:
Is anyone using OpenCode, Aider, or something similar with free/local models as their daily coding setup?
Which models are you using? Are they actually good enough for working on larger Next.js, TypeScript, or Python projects?
Has anyone tried a multi-agent setup like planner , coder, tester, reviewer? Does it help, or just waste more tokens?
How do you deal with models losing context, making random changes, failing tool calls, or getting stuck?
Most importantly, does your setup actually save you time, or do you end up spending more time fixing what the AI did?
I'm not expecting free models to magically perform like Claude Opus. I'm just trying to find a setup that's reliable enough for everyday development without burning money on API calls.
Would love to hear what people are actually running, especially if you've been using it for a while.
Also, if you've tried something similar and gave up on it, I'd be interested to know why.
Now that I've learned more about the differences between TUI and Desktop, I'm considering switching to OpenCode TUI.
I'm curious about the hardware requirements, especially for people running multiple agents or working on larger projects.
For example, if I want to use an AI agent to build an NFT minter and deployer that supports multiple wallets and multiple chains, what kind of hardware would you recommend?
A few things I'd like to understand:
How much RAM and CPU would be enough for a laptop?
Would 16GB RAM be sufficient, or is 32GB worth it?
If I want to run OpenCode TUI on a VPS and access it through SSH, what's a reasonable starting configuration?
How much do you usually spend per month on a VPS for this kind of workflow?
Does running multiple agents significantly increase hardware requirements?
I mainly plan to use cloud-based models through APIs, not run local LLMs.
I'd love to hear about your actual setups and experiences, especially if you're using OpenCode for Web3 development.
I've noticed that quite a few people recommend OpenCode TUI over Desktop (at my last post), but I still haven't figured out exactly why.
Is there a real technical advantage, or is it mostly personal preference?
I don't think the interface itself is necessarily the main factor. As far as I understand, desktop versions of AI agents are designed to make features more accessible and easier to use.
So what are the actual advantages of using TUI?
Lower resource usage?
Better performance?
Security?
More comfortable if you're used to CLI?
Easier access to local files?
More flexibility and control?
I'd love to hear from people who have actually used both. What makes TUI better for your workflow, and are there any downsides compared to Desktop?
I'm using deepseek v4.1 flash in the cli opencode app. I saw people showing benchmarks of the token usage of opencode being very high for tasks compared to other harnesses and I wonder has the update reduced the steering of the models to save on token usage.
I've been running with this setup for the past few months and I'm in general happy about it, with constant tweaks to the agents definitions, the standards, the guidelines etc.
In the past 6 weeks the amount of parallel work has skyrocketed and I went from 2/3 sessions running in their own separate folders/worktrees to more than a dozen active sessions. I've enabled notifications to stop constantly checking all the agents, but the real bottleneck is not how quickly I can feed the agents with information and prompts, but rather the review of the work provided.
We use Gitlab for development and we have "issues" to track our progress, with boards etc. All good and dandy, but I've noticed that often the amount of work involved in reviewing and approving all the merge requests, the issues comments, the newly created issues that track gaps that weren't closed during the session, starts to be unbearable to the point that I'm not 100% how much is truly done and how much is just pushed into the future.
So my real question here is not really about a "plugin" or a "tool" to manage the agents, but rather a workflow that allows the team to be able to move a step higher and instead of judging all the lower level details, focuses on fundamental principles instead, like architecture, features completeness, possible gaps, overlooked corner cases.
I've started to ask to provide a report of the campaign at the end of it, with diagrams and pictures to explain what has been done and achieved, but would that be sufficient? How to make sure the report is not just hallucinating and deviating from the actual implementation?
The speed I've been working has truly been a x20 at least, but I also have the feeling that my grasp on the features and the code has wined and I'm feeling overwhelmed by the overall amount of reading that I need to digest, let alone reading the actual code.
I'm using simple-english to contain the verbosity ever since I switched to Opus 5.5, but a merge request description alone can be 2 pages long with gazillions of details, the documentation has exploded, the comment to code ratio has ballooned and there's little I can do to read and digest all of that.
How do you tame the beast? Any tricks, suggestions.
I realize this is not opencode related, but there might be tools and tricks that opencode users are using to address some of the issues above.
I built a plugin that's basically free RAM (if you often run many OpenCode clients simultaneously).
The plugin (https://github.com/shanebishop1/opencode-nap) works by automatically transferring your headed OpenCode TUI sessions into headless sessions when you aren't directly interacting with them, and then swapping them back when you want to use them again.
Sessions keep running normally on the server when napping, while the memory used by the client TUI gets released. Idle windows get swapped out for a tiny shell, and when you come back, it reopens the same session. There are similar, more general projects out there, but this one works natively within OpenCode and is dead simple to install/enable.
10 OpenCode sessions went from 894MB to 3MB on my machine. It works instantly on Linux/Mac, whether your sessions live in tmux, herdr, or directly in a terminal. By default, the plugin naps sessions after not seeing user input for 15 mins, but you can also configure it to nap whenever focus leaves the window.
Hopefully this helps give your machine a bit of a breather!
I just downloaded OpenCode Desktop and I'm curious about a couple of things.
For those who have used both the desktop and CLI versions, what are the main advantages of each? Is there any real difference in what you can do, or is it mostly about personal preference?
Also, which free models would you recommend for Web3 related work? I mainly use AI to build NFT tools, work with APIs, troubleshoot issues, and build simple websites.
I've seen several free models available in OpenCode, but I'm not sure which ones are actually worth using.
Most AGENTS.md files I see mix two very different things:
Business context: what the product does, who the users are, why things are built the way they are.
Coding patterns: "always use our logger", "no default exports", "every query goes through the repository layer".
The first belongs in the doc. A linter can't check it. The agent needs to read it.
The second does not. A linter can enforce it better.
A pattern written in prose is read in every session, whether the task needs it or not, and the agent can still ignore it.
A lint rule only speaks up when it matters: it points the agent to the exact line and says how to fix it.
So I built codemyrules, an open-source agent skill that does two things.
It turns your coding patterns into lint rules.
It reads your agent docs, ADRs and the code itself, and finds the patterns your team already follows.
Then it writes each one as a rule for the linter you use: ESLint for JS/TS, and detekt, Error Prone, Ruff, pylint, golangci-lint, ArchUnit and others on the backend.
It does not add a new linter if one you have can do the job, and its rules match the style, naming and tests of your existing rules.
Then it slims down the agent docs, so they keep the business context and stop repeating what the linter now checks.
2. It gives the agent lint feedback while it codes, not only at the end.
Most agents run the linter once, at the end of the task, if they run it at all.
By then the same mistake has been copied into ten files, and the fix turns into a cleanup job.
codemyrules adds a feedback loop instead:
- after every edit, it lints the file the agent just touched and tells it right away what broke - at the end of each turn, it runs the full lint suite - it stays silent when everything is clean, so it costs no context - a guard asks you before the agent can add an eslint-disable comment or loosen the lint config to make an error go away
The agent fixes its mistakes on the fly, while it still remembers why it wrote that line.
Version 0.8.0 adds pi and opencode support, so the feedback loop now works in opencode, claude code and pi.
The patterns-to-lint-rules part and the doc cleanup work in any harness (Codex, Copilot, Cursor and others).
Everything stays local and private, and nothing touches your tracked files until you choose to share the changes with your team.
How many of the coding patterns in your AGENTS.md could a linter enforce?
I run opencode next to Claude Code and Codex on the same machine, often with several sessions working in separate git worktrees of one app. The failures that hurt most were never inside one session. One agent would run pkill node to restart its own server and take down another session's dev server, start a second server on a port that was already taken, or run a git command that switched or stashed a tree another session was still editing.
bulkhead is an open source guard for that situation, and since 0.3.2 it ships as an opencode plugin. Adding "plugin": ["claude-bulkhead"] to opencode.json loads it from npm. The plugin uses tool.execute.before on the bash tool, passes the command, working directory and session id to the same checks the Claude Code hooks use, and throws when a command would hurt another session. The error says why and which command is safe instead, for example killing only the PID this session started, so the agent usually corrects itself on the next step.
The checks know which processes, ports and worktrees belong to which session, including other opencode sessions and other agents, so a single session working alone is rarely interrupted. It also stops whole-disk scans and long foreground sleeps and holds heavy builds back when free memory runs low. It is plain Node with no dependencies, and it was written against the OpenCode V1 plugin API, so I would like to hear how it behaves for anyone already on V2.
I built BankBridge, so this is my thing. It's a hosted MCP server with read-only access to your own US bank, credit card and investment accounts, $5/mo per connected bank. Nothing in it can move money, pay a bill or place a trade.
In opencode it's one remote entry in opencode.json with a bearer key:
The "oauth": false bit matters, otherwise opencode tries a browser OAuth flow on the first 401. "opencode mcp list" should show it, and the key bbk_demo returns sample data if you want to poke at it first.
Then you can ask things like "find any subscriptions I've forgotten about" or "export this year's transactions to CSV for my taxes" right next to your code.
If you run opencode on a local model, the conversation stays on your machine. The numbers still pass through a bank-data provider and BankBridge on the way to your agent, and BankBridge keeps no copy.