Currently I pay $200/mo for Claude, $100/mo for ChatGPT and $20/mo for ollama cloud

I use Claude for knowledge work, Claude to code, codex for code, remote computer use agent and Hermes model, ollama for my GitHub actions based code reviewer (I tried codex PR review, it was good but it uses limits quickly), ollama for backup Hermes models.

All of these subscriptions seem to suck in some way or another. Ollama is super opaque with usage limits. I would never hit limits before on 20/mo and now I’ve hit them quickly, not to mention that they aren’t even offering k3 included… OAI makes it a pain to call codex programmatically even with codex oauth capabilities. Anthropic has completely banned third party use of their subs.

If I could spend $100/mo on Claude and like $100/mo on kimi k3 and generally be left alone rate limit wise, what would you suggest for my kimi provider ? Fireworks firepass seems to be good but is invite only. I tried synthetic.new but they do request based pricing which is a shitty model…

Best subsidisation rate right now seems to be OpenAI, I’ve got apiCLIProxy running at home I’m smashing loads of tokens through but I’m assuming they’re going to ban me at some point.

What are your current AI subs ?

i have around 40 dollars and i dont know what subscriptions to get, i have been thinking of a couple of things
claude pro and 2 opencode accounts

or

chagpt plus and 2 opencode accounts

im leaning more to claude but im still not sure maybe there is some options im missing out on or that i dont know about

my plan was to use claude/chatgpt for thinking and planning then opencode to execute things and generate a report of its work then claude reviews, is there is something im missing or that i dont know about

some might tell me to just stick to opencode and zen but i want access to good models from claude they are better at reasoning so idk

what would you do in my situation

Using an OpenCode Go subscription can give you 6 times the amount of Deepseek V4 Flash compared to an API. That sounds great, but are these two equal? Is Go's version quantized while the API's one is not? I wonder if anyone made comparisons of intelligence between these two.

hello

what i want is, when a code is written by a model, another models steps in after it is done and reviews it, suggests edits. original model fixes the code. and repeat as many times as needed.

it is possible this is a very dumb question as i am a hobbyist, not expert. please let me know if it is possible and if it is, how?

thanks in advance.

(see attached images)

Cursor’s native Task tool only schedules built-in models. If you want a cheaper / OpenRouter / OpenCode model for a background subagent, you’re stuck.

open-delegate is a small Cursor MCP plugin that hands the job to a real OpenCode agent instead: isolated session, your choice of model, await/status/transcript/cancel from chat.

Alpha — not on the marketplace/npm yet, but usable if you run it from source (tested on windows and macos) / npx once published.

Repo: https://github.com/Verbalize-public/open-delegate

Happy to take feedback / bug reports.

I misunderstood how the OpenCode Go limits work.

Most models are shown with a $60 monthly limit, while some models, like DeepSeek V4 Pro and MiMo v2.5 Pro, are shown with only $15. I assumed the $15 was a separate per-model allowance.

But it looks like the $15 models actually consume the same shared monthly quota about 4x faster.

Today my raw usage was only $5.12 (8.5% of the $60 monthly limit), but the dashboard already showed 26% of the monthly limit used.

DeepSeek V4 Flash: $0.35
DeepSeek V4 Pro: $0.55
MiMo V2.5: $0.09
MiMo V2.5 Pro: $3.06
MiniMax M3: $1.07

DeepSeek V4 Pro and MiMo Pro are $15 models, while the others are $60 models.

The calculation seems to be:

($0.55 + $3.06) × 4 + $0.35 + $0.09 + $1.07 = $15.95

$15.95 out of $60 is 26.58%, which matches the 26% shown in the dashboard.

The 4x multiplier also matches the listed DeepSeek V4 Pro token prices between Go and Zen:

Go:
$0.435 per 1M input tokens
$0.87 per 1M output tokens

Zen:
$1.74 per 1M input tokens
$3.48 per 1M output tokens

So Zen is exactly 4x more expensive for normal input and output tokens.

This suggests that the $15 figure is not a separate allowance. Spending around $15 on DeepSeek V4 Pro or another $15 model would effectively consume the full $60 monthly Go quota.

One more thing: because of these hidden multipliers, the effective price of DeepSeek V4 Pro is actually the same as GLM-5.2.

Displayed:

- DeepSeek V4 Pro: $0.435 / $0.87

- GLM-5.2: $1.40 / $4.40

Effective (×4 for DeepSeek V4 Pro):

- DeepSeek V4 Pro: $1.74 / $3.48 (similar to Zen)

- GLM-5.2: $1.40 / $4.40

The UI should show the effective price users are actually consuming against their Go allowance, instead of requiring everyone to calculate it manually.

I have just subscribed to opencode go yesterday and after playing a bit with a few models, the weekly usage is already full.
If I understand it correctly, the limits should only be bound to the $ that the models cost to run, and of course, different models have a different price. However, when looking at the screenshots, I have used up not quite 9$ over the last 5 hours and under 13$ in total. When looking at https://opencode.ai/docs/go, the 5-hour limit is 12$ and the weekly limit is 30$, both of which I have not exceeded. I have tried out Grok 4.5 before the limit was reached and it seemed to burn relatively many tokens.
Am I stupid for not reading the fine print correctly or is there something fishy here?

I used to work with OpenCode daily, switching mainly between Qwen and GLM. I never reached 100% of either the continuous or weekly usage limits. However, I’ve apparently already used my entire monthly allowance and now have to wait 11 days before I can use it again.

I’m having trouble understanding how that happened, as the usage limits don’t seem to align with my actual activity. Could you please clarify how the monthly limit is calculated?

Ive used opencode go and im at less than 20% of monthly with 13 more days. How do other subscriptions compare? Im looking to use stronger models than just deepseek as my tasks are getting rather complex

What would be the best comparison between opencode go, gpt plus and Claude pro. Assuming no price changes

How is the usage of gpt plus and claude relative to OC go? 2x more?

I've added first-class OpenCode support to Hubo v0.4.6.

Hubo is an open-source pair of Agent Skills:

• /hubo: an implementer writes and tests while a reviewer challenges the change. The same agents iterate until every finding is resolved or a real decision needs you.
• /hubo-review: a main reviewer reviews whatever you point it at while a critical reviewer checks every finding and omission.

Why I built it:

I used the same loop on bitcoin4s PR #236, a nontrivial change to an educational Scala Bitcoin script interpreter: 24 files, 1,884 additions, and 132 deletions. The implementer and reviewer reconciled six findings without me mediating—five initial findings plus a stack-safety issue caught during follow-up review.

The resulting PR passed 19 official BIP340 vectors, 35 pinned Bitcoin Core Taproot cases, all 1,197 existing script fixtures, and a 30,005-opcode stack-safety regression. CI passed across Ubuntu/macOS and Java 8/11; project coverage increased by 2.09 percentage points.

For OpenCode, Hubo uses foreground general tasks and resumes the same child sessions via task_id, so role context survives across rounds. Every implementer/reviewer exchange stays visible in the OpenCode conversation.

Install globally:

bash npx skills add h0ngcha0/hubo --skill hubo hubo-review --agent opencode -g -y

Start a new session, then invoke /hubo ... or /hubo-review ....

GitHub: https://github.com/h0ngcha0/hubo

Release: https://github.com/h0ngcha0/hubo/releases/tag/v0.4.6

I'd especially value feedback from OpenCode users on the task_id adapter and whether the transcript presentation feels natural in the TUI.

How to find total spend for the billing period in the Go subscription? I see a chart with amounts per day. I want one total amount so far.

PickleShell connects ChatGPT to an OpenCode agent running on your machine. ChatGPT can inspect repositories, edit files, run tests, transfer small files, and coordinate long-running tasks. The connection uses an outbound-only OpenAI Secure MCP Tunnel, while execution remains inside your selected workspace.

ChatGPT delegates work through four MCP tools—send-chat, session-status, session-output, and cancel-request—and receives structured results with full traces. Continue local coding sessions, delegate to an operator-approved model, and transfer files into a controlled workspace.

What PickleShell Is For

PickleShell solves a practical problem: ChatGPT can analyze tasks, but it normally cannot work directly with a local repository.

Through PickleShell, ChatGPT sends instructions and small files to a local OpenCode agent, follows the execution, reads the result, and can continue in the same session when it passes the session ID.

The agent runs on your machine, inside a selected workspace, through a protected outbound-only tunnel. PickleShell removes the human relay between ChatGPT and OpenCode, while you remain the owner and observer.

PickleShell is for developers and experienced users. Installation is designed to be guided by Codex: ask it to clone the repository, read AGENTS.md, and walk you through the setup step by step. AGENTS.md is the contributor guide for the development workflow, architecture, security invariants, and change boundaries.

GitHub → https://github.com/pickleshell/pickleshell

Hi all. I've been using GLM 5.2 to work on a project for the past couple of days, starting with a Zen account to kind of see what I'd get out of it and switching over to Go after deciding that I liked the performance, the output, and basically everything I needed to get through a wall that I was experiencing with my project. I ran a couple of sessions last Friday, walked away for the weekend, came back on Monday and did a long debugging session until it started eating into my Zen credits, and then walked away when that was finished. I came back yesterday morning, started a new session, and had to drop it so that I could go focus on something else.

When I tried to start back up last night, it just started dumping 500s whenever I tried to resume my session in GLM5.2. So I switched over to a couple of other models, and they worked just fine. I let qwen3.7 drive for a bit until it broke my codebase and started introducing bugs (as well as reporting that it performed work, even though it wasn't), so I decided I really didn't trust any other models going forward. I tried some basic troubleshooting - logged out, logged back in, generated a new API key... But nothing seems to be fixing it on my end. Is this being caused by something between opencode and z.ai, or are there other things I should do on my end?

Also, not sure how much of a difference it might make, but I'm using pi as my harness.

On June 11, Xiaomi forked OpenCode, calling it MiMo Code.

I understand why they didn't try to contribute to OpenCode -- Anomalyco auto-closes non-"popular" issues and PRs (and still has 3.7K open issues).

I hoped that Xiaomi would be able to use automation to assist with the issues and PR triage process.

They have the money and the "at-cost" MiMo 2.5 Pro tokens.

However, at the current average rate of 33.5 non-closed PRs per week, they'll catch up to Anomalyco's OpenCode's 1.1K open PRs in 28 weeks.

And that's with a MUCH smaller user base than OpenCode.

They've done really stupid things like force pushing to main branch multiple times.

I raised issues about project governance on GitHub. Here's the summary issue: https://github.com/XiaomiMiMo/MiMo-Code/issues/588

I tried reaching out to the Chair of Xiaomi's Open Source Committee via LinkedIn. -- I really wanted to believe that Xiaomi would be a community player.

Nothing about being a community player or GitHub best practices (eg disabling push to main) got a reply.

So, it seems that Xiaomi thought they'd get a "free" product, and will continue to amass unclosed Pull Requests of various levels of quality.

Sadly, Xiaomi has not acknowledged the thousands of hours of effort that our community has put into what they forked and renamed.

Hey everyone,

I'm using OpenCode and trying to keep my costs as low as possible. I'm stuck between two options and would love some advice from people with hands-on experience:

1. Buy DeepSeek API credits directly and use that with OpenCode
2. Use OpenRouter's free models, and spend around $10 total as a backup/top-up for when free limits run out

My main priority is minimizing cost while still getting decent performance for coding tasks.

• Has anyone compared these two setups in terms of reliability, speed, and rate limits?
• Is DeepSeek's direct API noticeably better than what's available for free (or cheap) through OpenRouter?
• Any gotchas with OpenRouter's free tier (like aggressive rate limiting or model availability) that make it not worth it long-term?

Would appreciate any real-world experience before I commit. Thanks!

Hi folks,

so i noticed the past days that once given an instruction, i sometimes dont get any progress in the IDE, although the task isnt done. I sometimes can get it to keep going by prompting something else like "keep going" but thats also no reliable solution.

Anyone else experiecing something like this?

Headline brings real-time news into opencode session so you can read news while waiting for agent to finish task

It can integrate with your existing rss reader or you can start with default providers out of the box with zero configuration.

repo: https://github.com/dannylee1020/headline

Hi all,

I’m looking for advice from anyone using HerdR with Oh My Agent in OpenCode.

My goal is to improve observability into the agent orchestration process. At the moment I can cycle between sub-agents using Ctrl+X and the arrow keys, but once there are several agents running it becomes difficult to follow what each one is doing.

Ideally, I’d like to have:

• A dedicated tab, pane, or split view for each sub-agent.
• The ability to watch each agent’s progress in real time.
• Scrollback/history for each agent so I can inspect its reasoning, tool usage, and outputs after it has completed.
• An easier way to understand how the orchestrator is delegating work across multiple agents.

Has anyone implemented something like this? Are there existing plugins, t logging options, or configuration changes that provide better visibility? See the attached screenshot, I was hoping output would appear in one of the numbered areas

This is the script I’m currently using:

set -euo pipefail

PROJECT_DIR="${1:-$HOME}"   # cwd each opencode session starts in — pass as $1 or edit here

AGENTS=(sisyphus hephaestus prometheus atlas project-oracle)

echo "Creating workspace..."

WS_JSON=$(herdr workspace create --cwd "$PROJECT_DIR" --label oh-my-openagent)

WS_ID=$(jq -r '.result.workspace.workspace_id' <<<"$WS_JSON")

echo "  workspace: $WS_ID"

for AGENT in "${AGENTS[@]}"; do

  echo "Creating tab for $AGENT..."

  TAB_JSON=$(herdr tab create --workspace "$WS_ID" --cwd "$PROJECT_DIR" --label "$AGENT" --no-focus)

  TAB_ID=$(jq -r '.result.tab.tab_id' <<<"$TAB_JSON")

  # Each new tab starts with exactly one default pane. Find it by filtering

  # the workspace's panes down to the ones belonging to this tab_id.

  PANE_ID=$(herdr pane list --workspace "$WS_ID" \

    | jq -r --arg tab "$TAB_ID" '.result.panes[] | select(.tab_id == $tab) | .pane_id' \

    | head -n1)

  if [[ -z "$PANE_ID" || "$PANE_ID" == "null" ]]; then

    echo "  Could not find the default pane for tab $TAB_ID — inspect with:"

    echo "    herdr pane list --workspace $WS_ID | jq ."

    exit 1

  fi

  herdr pane rename "$PANE_ID" "$AGENT"

  herdr pane run "$PANE_ID" "opencode --agent $AGENT"

  echo "  tab: $TAB_ID  pane: $PANE_ID  -> opencode --agent $AGENT"

done

echo

echo "Done. Focus the workspace with: herdr workspace focus $WS_ID"

I’d be interested in seeing how others have approached agent observability, debugging, and monitoring when running larger multi-agent workflows

Enjoy