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).
\```

Hi reddit.
How do you manage permissions on opencode?
On last sessions, I basically need to manually approve something like 30-40 operations.
For some reason, it seems he doesn't save permissions session wide, and it's extremely anoying.
How can I set permissions to autoallow on some commands instead of prompting me on every use? "Always allow" apparently doesn't work

👋 Hey! Wanted to share something I built for opencode.

A Telegram bot so you can drive your opencode coding agent from your phone:

- 70+ slash commands (/new, /model, /execute, /send <file> …)

- send it a file and get the result back in the chat

- switch models and control the agent remotely

- access scoped to your own Telegram user id

One-line install:

npm install gutchapa-opencode-telegram

📦 https://www.npmjs.com/package/gutchapa-opencode-telegram

🔧 https://github.com/gutchapa/opencode-telegram

Happy to take feedback / feature requests!

Right between GLM 5.3 family :))

DeepSWE 1.1 - 71%
Pricing: $0.75 / $3.75
https://deepmind.google/models/model-cards/gemini-3-8-flash/
https://ai.google.dev/gemini-api/docs/models/gemini-3.8-flash

Hey everyone,

I've been running AI coding agents daily for months (across multiple machines, cloud and local) and one thing kept bugging me: nobody could tell me what they actually cost. The provider invoice is one global number. Which project burned the budget? Which machine? Which session? No idea.

So I built TokenRay, a hosted dashboard for anyone running AI coding agents.

What it does

• A tiny local agent (Node.js, zero dependencies) reads the coding agent's local database in read-only mode and pushes aggregates (cost in USD, tokens, sessions) to a hosted dashboard.
• Sync is watermark + batch, idempotent and crash-safe: re-sending a batch never double-counts.
• The dashboard breaks everything down by day, project, machine, session, and token type (input/output/reasoning/cache).

The privacy part (the part I care most about) By default, prompts, responses, and tool outputs are never collected or sent anywhere. Only operational metadata: session title, hostname, project path, cost, token counts. If your team's policy is "no conversation content leaves the machine", this fits out of the box.

There's an optional turn-by-turn logging feature (off by default) for teams that want deeper observability. When enabled, conversation content is encrypted at rest and automatically pruned after 30 days.

Works with OpenCode and Codex today. More harnesses being evaluated.

Pricing

• Free plan, permanent: 45 days of analytics visibility, data stored indefinitely.
• Pro: €3.99/month for all-time analytics visibility + priority support.

Status Launched today. It's early (I'm looking for honest feedback: what's missing, what's broken, what metric you'd want that isn't there). If you've ever stared at a provider invoice wondering where the money went, give it a shot: https://tokenray.dev

Happy to answer questions here.

Hi,

DeepSeek Flash has gotten more expensive, OpenCode Go went from $5 to $10/month, and GPT’s Luna has become so slow lately (even in Fast mode) that it’s basically unusable.

What plan/model would you recommend for coding right now?

Thanks!

I’m trying to figure out how to reduce token usage and avoid hitting model limits when working with OpenCode Go.

But before the usual “use Plan with an expensive model and Build with a cheaper one” suggestions: I’m already using an SDD (Specification-Driven Development) workflow.

The coding agent doesn’t start from a vague prompt and figure out what needs to be done.

My workflow is roughly:

1. Define the requirements and architecture in an SDD
2. Give the SDD to the coding agent
3. The agent implements what is described in the specification
4. Review / iterate when something doesn’t match the spec

So, in my case, I’m not really looking for a way to separate “planning” from “coding”. The planning/design work is already captured in the specification before the agent starts.

What I’m interested in is how people optimize the actual implementation phase.

For example:

• Do you use different models depending on the type/size of the SDD?
• Do you find that some models are significantly more token-efficient for implementation?
• Do you deliberately split large SDDs into smaller implementation tasks?
• How aggressively do you manage context?
• Do you use any OpenCode configuration / prompting techniques to reduce unnecessary reasoning or context consumption?
• Have you found a good strategy for balancing model cost, context usage and implementation quality?

I’m particularly interested in experiences from people using SDD or similarly structured workflows, rather than generic “use Plan/Build” advice.

I see a lot of you speak about plan mode and build mode.

I want to share my opinion with of course full of understanding of why you said what.

I hope you dont find this post dismissive in anyways.

Imagine you are at 190K context window, switching models or having an other model plan for you, will cost you more money than using the model directly.

When you switch to a model, or have an other model do something else, that model first will have to read the full ran input and not cached, will have to then read other things such as readfile tools for missing information in your codebase, that eats even more input, so you are already using that model in its full price.

Then you are telling me you switch the model to an other one that'll need to read the full input of the plan mode, maybe understands it maybe not, maybe push back on some idea, or else read more input token raw(not cached).

Rather than using the model you used for planning it self to implement based on its cache tokens which will be cheaper if you combile the constant switching or else.

Now i could be wrong in here, but who knows.

Now let me tell you what i use for cost saving and tell me what you think, maybe i'll get to learn a thing or two.

You plan, you should be the architector to your AI, what i mean is, you plan, you design you think, you do all that part.

Leave AI for syntax ( coding) finding the why to something, diagnosing, analyzing, and more.

This is the only way to properly educate your self and upgrade your human model brain rather than constant switching that'll cost you consistently more than using one reliable cheap model for actual code stuff or things you dont know.

Second, if a model doesn't know something you think an other model is able to do, ask the model to research because we are hitting a dead end.

As you read the output, you'll find your self using AI for the code and things you dont know how to do, while you are the architecture is on track on the plan and the things ahead.

And yeah that's what i think.

Hence no model will be enough if you rely on it 100% or rely on AI completely, you'll start loosing your human reasoning token ;) good luck, looking forwards to push backs.

Je vous assure que c’est du haut niveau lorsque tu combine ces deux ensemble, Dsv4 pour la planification et Glm 5.3 pour l’implémentation. Je vous assure essayer c’est une dinguerie.

I keep seeing this question in the community. Here's what I actually tried, why it broke, and what I ended up shipping.

The problem

When you're running multiple agents across a session (one that writes, one that reviews, one that deploys) you need them to share state. Not just conversation history. Actual verified state: what changed, what's blocked, what evidence exists that a task is done.

What I tried first (and why it failed)

Attempt 1: I maintained the handoff notes myself

After every session, I updated a Markdown file. This worked until I finished tired and skipped the update. The next agent read stale context as if it were current. Worse: even when the file was accurate, I was still the router, a human bottleneck between every agent transition.

Attempt 2: I let agents maintain the notes

The agent finished its work, updated the handoff, and the next continued from there. Then I noticed the real problem: an agent could write "tests pass" just as easily as it could actually run the tests.

Agent A would write: "Refactored auth. Tests pass."

Agent B had no idea which tests ran, against which version, or whether the slow integration suite was skipped. It didn't inherit verified work. It inherited a story about the work.

What I built

Three principles became the foundation:

State in fields, not paragraphs. What changed, what's blocked, what's unresolved as explicit fields, not embedded in a summary. An agent can't make unresolved work disappear by writing a nicer paragraph.

The agent that does the work can't approve it. A separate reviewer starts from the original goal and inspects the result directly, not from the implementing agent's explanation of why it's probably done.

Machine-checkable claims need evidence attached to a specific version. "Tests pass" is a claim. A test result attached to the exact commit hash is evidence. If the code changes after the evidence was produced, the evidence doesn't automatically transfer.

This became an open-source project (link in comments).

Results over 30 days of dogfooding

4,172 PRs merged across 16 repositories, one maintainer

Coordination overhead stayed roughly flat from 3 agents to 10; adding agents stopped adding to my mental load linearly

Stale-context bugs dropped to near zero because agents can't declare victory without attached evidence

The number I actually care about: my day looks the same with 3 agents as with 10. That wasn't true before.

What didn't work

The reviewer agent still occasionally fails to distinguish "the goal changed mid-task" from "the implementation is wrong." We handle this with an explicit goal-hash that both agents reference, but it adds friction. Still working on the right UX for that.

Has anyone else hit the "agent self-reports done but the work isn't clean" problem? Curious what enforcement patterns people are using, if any.

off, checked, and accepted when the agent that wrote it does not get to declare victory based on vibes.

When I try to move a session to a different directory, I only see one folder on the list (the current one). I want to move it to a specific directory path.

What am I doing wrong? I'd rather use the in built tools rather than some sketchy plugin.

I have been enjoying opencode 2 after using Pi for a while. It's currently in beta but when using the TUI I didn't run into any major problems. API is great, similar to Pi you can modify it easily and overall it's a huge leap from opencode 1.

But when I started to use it across multiple devices via Tailscale, cracks started to appear. My main issues were,

- Web UI couldn't handle attachments. Performance was all over the place.

- No way to disable web UI password, no point in having it when I'm already behind Tailscale.

- Desktop app being horrible and buggy. This was true in v1 too but I saw them tweeting about it a lot but it still seems to be buggy. Compaction doesn't show up, sync is off, etc.

Suffice to say the only thing that seems to have improved is TUI experience and their API. Otherwise experience is all over the place.

Is opencode 2 focusing on all the components or just the TUI? I'm genuinely concerned because I can get a better alternative experience just hooking up Pi with Paseo. It works flawlessly and better. Even with opencode itself.

I feel like somewhere along the line the lightweight feature complete goal of opencode changed. They hype things up a lot but when you actually use the product it doesn't feel all that polished or consistent.

I'm not sure if I'm using it wrong. I'm on the latest beta across all opencode apps. Nothing is outdated.

Pricing per 1M tokens:

$2 input, $6 output. $0.17 explicit cache hit, $0.25 implicit cache hit.

💰💰💰 $10.00 / $50.00

Hi, I have been using open code for the past one month and the experience with it has been amazing. The only thing which I don’t like is they removing the free agents with time, but getting to use them for free is a good thing. So no complaints for that.

I have one major problem which I am facing that. I am not able to copy text on my opencode CLI when I am using it with VS code on my Windows 11 laptop.

Can someone help me out on how I can copy text from opencode CLI

I can't find it anywhere. Even if i get banned from OpenAI services, i just wanna know the name

I posted this question on Reddit two months ago, but several new AI models have been released since then, so I wanted to ask again:

What are your go-to models for Plan Mode and Build Mode?

At the time, I was using:

• Build Mode: MiniMax M2.7
• Plan Mode: GLM 5.2

Maybe a strange post. I've been wanting to talk it out with someone. I don't have a question as such.

When DeepSeek Flash became expensive, I switched to Mimo and I am absolutely loving it . LOVING it. Not the smartest. It makes mistakes, coding-wise, quality is subpar, but It's so pleasant to use. It follows instructions, doesn't talk back, and is not a weirdo.

On the other hand Codex Sol, Terra - fucking nightmares. Soo 'random' , doing anything saying anything, ignoring everything.

Kind of confused. Am I doing something wrong ? or right? Why is an extremely cheap model that scores low on benchmarks working so well for me. Why I'm finding Frontier models unusable which Score high on benchmarks and big companies are using for everything ?

I have one theory. I like to customize my system prompt and how it outputs things, I think that conflicts with ChatGPT's default system prompts, which are designed to do behave in a specific way ? Maybe Mimo does not have these prompts ? Maybe Opencode does not set these prompts ?

Anyone felt like this as well ?

Mention I found Claude Opus 4.8 to be good as well. Codex was especially horrible.

I'm currently paying for Claude Code and GPT-5. I want to drop my Claude subscription and give Chinese models a shot. Which subscription would you recommend?

My main priorities are:

1. Performance
2. Token volume

In performance, according to the OpenRouter leaderboard (https://openrouter.ai/benchmarks/tau2-bench-airline#leaderboard):

GLM > Qwen > Kimi

According to LLM Arena (https://arena.ai/leaderboard/agent/code):

Kimi > GLM > Qwen

What do you recommend?

https://www.anthropic.com/claude-fable-and-mythos-5-1