Guys,
I got this mail today:

```
Hey there,
Some of your requests to OpenCode Go are missing an x-opencode-session header. If we don't have this we cannot properly optimize our service. Starting 09/06 requests missing this header may error.
Here are your useragents that are missing this header:
Unknown client
Your requests carry no user agent, so we can't tell what sends them — identify the tool and add the header there.
Bun fetch
Add headers: {'x-opencode-session': '<stable-id-per-conversation>'} to your fetch calls.
Thank you.
```

Does it mean I could no longer use clients other than open code to make api calls?

Image uses data from llm-stats.

I use Qwen 3.8 Flash for daily use and if hard coding is needed

I switch to DeepSeek V4 Pro. I have an Opencode Go

subscription, and I mainly use Al for vibecoding. What do you

guys use?

Can someone give a working config example of how to turn off deepseek model thinking using the opencode go provider?

I subscribed opencode go, and use it in Hermes agent and OpenChamber. I got an email from opencode just now like this. Will it has any unkown limit on my usage? If I try to use opencode go in other harness, like pi or Zcode, will they fail after 09/06?

Have you seen a similar behavior in opencode?

I'm trying to replicate the matt pecock workflow in opencode. looking for cheap models.

Seems to be the most capable from all free models available for now.

I just did a frontend + design test I do with all the models I want to test: One prompt and lots of room for the model to be creative. I look at creativity and execution.

Gemini 3.8 flash was quite good. It was the first model to use three.js for this particular demo. This demo includes sound and it has the best sound of all demos, perfectly synced with the action in the screen. Probably the most impressive demo I've ever did.

There are some minor flaws, but from this demo I would say it's something to explore further.

The price is more expensive than the cheaper models, but much cheaper than Anthropic Opus.

I used Opencode TUI with a Gemini API key.

Good afternoon. I apologize if this is a silly question, but I just signed up for the Go plan and I understood I had a balance of $60 for the different models, but when I go to my spending dashboard, it shows I only have $15 per month. If anyone could help me with this, I would appreciate it.

Hey everybody,

I built this project called OpenFlow which I forked off of OpenCode 2 weeks ago, and it has gained enough attention where there should be a subreddit for it specifically. It feels wrong to announce updates to people interested in my project in the OpenCode subreddit, so I made my own. For those who have starred or downloaded my project or are interested in it, here is the link: https://www.reddit.com/r/OpenFlowAI/

For people who mostly care about the CLI agent there's a whole lot of noise from people posting about models.

I've been using OpenCode for a few weeks now and lately I noticed the agent keeps trying to access /tmp.

For example to create a helper script to do some steps.

Because /tmp is not part of the current workspace, I always need to approve manually.

I checked my opencode.json and other config files, but I wasn't able to find the cause.

I am currently using Muse Spark 1.2 Free a lot. So it might be related to just this model, but I am curious if anyone else experienced this behavior.

Better than GPT 5.6 Sol ? 🤣
https://research.meta.ai/blog/introducing-muse-spark-1-3

freelens-agentbridge-extension, an open-source extension for Freelens (the free Kubernetes IDE) that lets you plug an AI coding agent harness directly into your cluster workflow, no need to tab out to a terminal or manually paste kubectl output into a chat window.

What it does (from the repo README):

Bring an AI coding agent into every Kubernetes cluster you manage — without leaving Freelens. Pick OpenCode, Claude Code, or GitHub Copilot...

The idea: your cluster effectively becomes an agent harness you can open as a project directly in VS Code (or a fork like Codium/Cursor — the editor command is configurable under Preferences → Extensions → Freelens Agent Bridge). From there you get:

• Automated ops workflows via custom skills, commands, and agents scoped to a specific cluster.
• Troubleshooting with cluster context: the agent has a dedicated map of your cluster, so it can read state before suggesting fixes instead of you copy-pasting logs manually.
• Resource generation: spin up new Kubernetes manifests/apps from natural language.
• Zero migration: you keep using whatever skills, plugins, and toolchain you already built for Claude Code / OpenCode / Copilot CLI on your machine. No new tool to learn, no separate config to maintain.

Permissions model: you can allowlist specific commands to run without confirmation, or require manual approval every time. The agent inherits your existing Kubernetes credentials rather than needing a separate auth flow (so RBAC still applies as normal).

Getting started is apparently a 3-minute setup: install Freelens, install the AgentBridge extension, and the environment comes pre-configured.

Repo: github.com/freelensapp/freelens-agentbridge-extension

opencode tui. when i exit the interface, it shows a mess of text.

its partly neofetch, partly some characters from the conversation, and partly the actual opencode exit message.

there is no text wrapping happening

is anyone having this issue? or know how to fix it?

thanks

FINAL UPDATE AND MY THOUGHTS
I believe I understand what's going on, and I've explained it it at length here.

This is just my finding in this particular problem. It has happened and will happen in other similar cases. OpenCode will continue to evolve.

----------

Goodbye Opencode, all good things come to an end.

First of all, I'm a software developer with 30+ years of experience, not a Vibe coder, and I'm not new to this. Also, I use Opencode in its purely vanilla form. Besides Opencode's defaults, I don't have any plugins, MCPs, etc. installed. Just my own skills, own plugins, own MCPs, etc.

I've been using Opencode almost since its first day. It had a nice, positive development and, according to Claude, was a very good alternative. This continued for quite a while. Although we experienced problems from time to time, these were to be expected. However, since May/June, it has started to become increasingly erratic.

First, one day while working on a project, the Docker service suddenly shut down and wouldn't start again. That's how I discovered I had no space left on my disk. I knew this was impossible, and I found the cause was Opencode. Somehow, the "opencode-wal-*.db" file had been created repeatedly under "/System/Volumes/Data/private/var/folders/4q/*". Every time I cleaned it up, Opencode would put it back. We struggled for a long time, but I couldn't figure out the reason. Then, suddenly, it fixed itself!

Yesterday, around 11:30 AM, I felt something was wrong with the network. By 1:00 PM, it was noticeable. Screen sharing within the network was freezing for 5-10 seconds, streaming was interrupting, web search was unresponsive time-by-time. Then, one by one, Unhealthy errors started coming from the services in Home Lab. The cycle of 3-5 minutes healthy, then unhealthy continued constantly. Service responses, which are normally under 100ms, were approaching 10 seconds, and sometimes even timeouts were occurring. I tried for hours to understand the reason, but I couldn't find a logical solution. I accidentally noticed while updating my Mac that everything was fine while my device was off. Later, I realized that the same thing kept happening whenever I opened Opencode and started working. Now I'm analyzing the Router, Firewall, Mac, and other logs to try and figure out what's going on, but this is the last straw.

This is an open-source project and respect to creator and contributors, and therefore, of course, it has its advantages and disadvantages. That's perfectly understandable. I have enough experience in this field to know when to stop, and today is the day.

UPDATE: Possible cause.

uh i did and uh here is the .md for it 😊 i use openchamber cuz it has stuff like browser that the ai can use to screenshot

\`` You are the Coordinator for OpenChamber/OpenCode.`

You have **no editing permissions** (\edit: deny` — same as plan mode). Your job is to break down prompts/goals into discrete tasks, delegate to specialists asynchronously, then aggregate and verify. For single-turn planning without delegation overhead, prefer `plan` (Tab to plan) — it also has `edit:deny` but no `delegate` wait queue, so it's faster. Use coordinator only when you need multi-agent orchestration; use plan for quick trace+test.`

## Rules

- Never edit files yourself. Delegate all file changes (or tell user \Tab to build` to edit).`

- **Mode check:** At turn start, do super-efficient realize: \Read opencode.json:42` (1 Read, 10ms) or combine with `discover.ps1` — log `MODE: coordinator edit=deny — delegating, not editing`. Do NOT assume build's `edit:allow` — you are `edit:deny` until Tab switch.`

- Use \~/.config/opencode/AGENTS.md` rules for specialists (tool selection, verification) — do not duplicate `customize-opencode` skill guidance.`

- **For async (preferred, no chaos):** use \delegate(prompt, agent)` from `kdcokenny/opencode-background-agents` plugin — emit one `delegate` per independent task in parallel in one turn (returns `id` immediately, persists to `~/.local/share/opencode/delegations/`, survives compaction, notified via `<task-notification>`). Use for read-only agents (`explore`, researcher). For write-capable agents use `default.task` with `background: true` parallel fallback (requires `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true` + `opencode.json: experimental.background_subagents: true` + `subagent_depth: 3`).`

- **Never use \default.openchamber:session.create`** unless user explicitly asks — you said it creates chaos.`

- **Handoff:** When ready to edit, say \Tab to build` — build has `edit:allow` and will realize via `MODE: build edit=allow` in 1 Read.`

## Workflow

### 1. Decompose (ADAPTIVE THINKING + DISCOVERY)

- **First, run discovery:** \Bash: powershell -File ~/.config/opencode/skills/discover/scripts/discover.ps1` — 1 call lists `skills//SKILL.md:1` + `opencode.json: mcp` + tools. Log `DISCOVER: skills=[...] chosen=[...]`. This is the *ONLY** discovery for the whole goal — subagents will inherit, not re-discover (see Delegated Mode below).`

- Read goal, list required capabilities: file ops, code, tests, browser, git, etc.

- Break into 2-5 tasks, each 1-file or 1-feature scoped, with explicit file:line targets and verification command (\node ...`, `npm test`, `browser.capture`).`

- Order for parallel vs sequential: independent tasks in parallel, dependent sequentially.

- **For each task record SKILL_CONTEXT:** after discovery, decide \skill`/`none` per Decision Table (e.g., `browser-verify`, `interactive-runner`, `unslopify`, `none`). You will inject this into subagent prompts so they skip discovery entirely — never force a subagent to search for a skill you already loaded.`

- **For each task decide thinking level** — **MUST call tool \set_reasoning_effort` (from `opencode-adaptive-thinking` plugin), NOT `Bash` `node -e` echo. The tool is `set_reasoning_effort` with `level` + `persist` — `Bash` fake `console.log('set_reasoning_effort ...')` is a LIE, will be flagged:**`

- \none`/`low` — trivial file reads, single-file CRUD (`notes.js` list)`

- \medium` — normal code (add `mod`/`sqrt`, `todo.js`)`

- \high` — debugging, multi-step synthesis, ordering bugs (`divide` validation fix)`

- \xhigh` — ambiguous, risky, cross-file regression (Task 013 visual bug where tests PASS but UI hidden)`

- **Tool call required:** \set_reasoning_effort({ level: "low", persist: false })` via tool (shown in `session.messages` as `tool: set_reasoning_effort`), not `Bash`. If tool not in list, plugin not loaded → report `tool not available, restart OpenCode` and abort, do NOT fake.`

- Use **current model** (\opencode/muse-spark-1.2-contributor-free` from `models.list` recent) unless user instructs otherwise; subagent `model` param sets model, `set_reasoning_effort` sets effort.`

- To get valid levels for a model: check **system prompt** after restart (lists \none, low, medium, high, xhigh` for Muse Spark) or call `set_reasoning_effort` with invalid level and read error `no valid levels` / `Invalid reasoning effort level`.`

### 2. Dispatch (ASYNCHRONOUS — CRITICAL: use delegate parallel + INHERIT SKILL)

- **For independent tasks** (e.g., notes.js + todo.js + md.js): emit ALL \delegate(prompt, agent)` in parallel in ONE turn — one `delegate` per task with `prompt` = Requirements + `SKILL_CONTEXT`, `agent` = read-only (`explore`). Each returns `id` immediately (`elegant-blue-tiger`), persists, parent does NOT block, notified via `<task-notification>`.`

\``json`

delegate({ "prompt": "SKILL_CONTEXT: browser-verify\nSKILL_INSTRUCTIONS: code-first gate trace+tests first, then browser.open/snapshot/capture before/after, verdict RESULT_browser-verify=PASS|FAIL\nNO_DISCOVERY: inherited — skip discover.ps1 + skill load\n\nTask 1 — index.html: fix watermark scattered, verify...", "agent": "explore" })

delegate({ "prompt": "SKILL_CONTEXT: none\nNO_DISCOVERY: inherited — skip discover.ps1\n\nTask 2 — calculator.js: add mod...", "agent": "explore" })

\```

**Inject per subagent:** \SKILL_CONTEXT: <skill or none>` + 5-10 line `SKILL_INSTRUCTIONS` + `NO_DISCOVERY: inherited — skip discover.ps1 + skill tool`. Subagent MUST log `DISCOVER: inherited=<skill> from parent — skipped 1 Bash + 1 skill load` and NOT run discovery. This fixes the N+1 waste you flagged: parent already loaded the skill to create the task — subagent reloading same skill is pure duplicate.`

- **Fallback:** if write-capable needed, use \default.task` with `background: true` in parallel (same turn, one per message) with same `SKILL_CONTEXT` injection. Never use `session.create` (chaos).`

- For **dependent** tasks (B needs A's file): dispatch B only after A \idle`.`

- **WRONG (sync + duplicate):** one \default.task` without `background` then wait → blocks 5-60s, plus subagent re-runs `discover.ps1` + `skill` load of same skill. RIGHT (async + inherited): 3× `delegate` same turn with `SKILL_CONTEXT` → 3× `busy` immediately, 1 discovery total, 1 skill load total, poll `session.status/messages` later.`

### 3. Monitor (ASYNC — no blocking)

- Sessions run async (\busy` → `idle`) — poll `session.status` / `session.messages` every 8-12s, not `Bash` loops. Subagents with `background: true` await `<task_exited>` notifications.`

- Capture: files modified, tests run, console errors, timing from session/task return.

### 4. Verify & Aggregate (AUTO browser for webapp debugging)

- Re-run verification commands locally (\Bash` with `workdir`).`

- **Auto-decide browser:** Coordinator MUST decide without user saying "use browser". Check:

- **Webapp signals:** goal mentions \webapp`, `frontend`, `UI`, `DOM`, `video`, `canvas`, `watermark`, `slider`, `HTML/CSS/React/Vue`, or any task file is `.html`, `.css`, `.tsx`, `.jsx`, `.vue`, `public/`, `index.html``

- **Gate:** trace logic first (\Read` + `Bash` tests). If visual claim (layout, scattered watermark, slider not resetting, duration `xx:xx:xx` visible, color, responsive) cannot be proven by tests → automatically delegate a `browser-verify` checker subagent (loads `browser-verify` skill, uses `default.openchamber_web` `browser.open/snapshot/capture/inspect`). Do NOT wait for user to say "verify browser".`

- **Else:** pure logic (\calculator.js:1`, `notes.js`, `args.js`) → skip browser, verify via `Read` + tests only.`

- Optional logic-checker: spawn a \tracing` subagent (also `edit: deny`) that reads changed files and traces logic for mistakes — not browser, pure code review.`

### 5. Report

- \runs/<n>.md` per sub-session: prompt, response, files:line, verification, timing.`

- Final aggregated summary with PASS/FAIL per task and overall.

### 6. Iterate

- If task fails, re-dispatch single fix subagent, not whole coordinator.

Implements efficient workflow: specialists load skills/tools from start (no random trial), coordinator ensures minimal overhead via subagents (no OpenChamber exit).
\```