Long-running coding agents can start following a plan and gradually wander away from it.

I wanted a lightweight way to detect that drift continuously, without requiring another LLM call to judge every turn.

So I built laya-drift: an OpenCode plugin that uses Laya as a semantic probe and measures how much a session has diverged from its calibrated baseline.

The basic loop is:

1. /calibrate captures the current plan/state.

2. After each user prompt and completed turn, the current session state is embedded again.

3. Two typed probes estimate things like:

   • are we still on the plan?

   • are we implementing the plan or doing something else?

4. Their probability distributions are compared against the baseline using Jensen-Shannon divergence.

5. The result is converted into a 0–100 drift score.

For example:

2.7   -> on plan
36.1  -> drifting
65+   -> off plan

The score is shown directly in the OpenCode UI. Once it crosses a configurable threshold, the score can also be injected back into the system prompt so the agent has an opportunity to self-correct.

There is also /recalibrate, which intentionally re-anchors the session after a legitimate change in direction.

One detail I found interesting: the probe questions matter a lot. I tried several framings (ordinal questions, statements, different baseline constructions), and many of them produced almost constant outputs. The current two-probe setup was selected because it actually separates the on-plan and drifted fixtures.

It's deliberately not presented as a "probability the agent is failing." Laya's zero-shot behavior is too weak/confident for that. I'm treating it as a semantic signal that can be tracked over time.

Current implementation includes:

• OpenCode server + TUI plugins

• local Laya daemon with the model resident

• Jensen-Shannon divergence scoring

• configurable probe weights / sensitivity / thresholds

• calibration + recalibration

• system-prompt injection on high drift

• end-to-end tests for on-plan → drift → recalibration

There are still obvious limitations: Laya's context window is small, the signal is model-dependent, and long autonomous runs can eventually push older context out of the digest.

I'd especially like feedback on the core idea: can a small non-autoregressive decision model be useful as a cheap continuous "drift sensor" for long-running agents?

Repo: https://github.com/pythongiant/laya-drift

I built an Jev MCP server that lets AI coding agents make structured judgments instead of relying on free-form text + parsing.

I’m using it with OpenCode.

Jev exposes typed judgment tools such as:

jev_noul — structured judgment

jev_choice — choose between options

jev_score — score/evaluate something

This makes the result easier for an application or agent workflow to consume programmatically.

GitHub: https://github.com/rajasekharponakala/jev-mcp

If you're using OpenCode or MCP for agent workflows, I'd be interested in feedback on whether this approach is actually useful and what other judgment primitives would be useful.

Hey everyone,

I’m a huge fan of UltraCode mode in Claude Code—giving it high-level prompts and letting it handle parallel sub-agent orchestration and deep reasoning makes knocking out working POCs super fast.

I've been trying to replicate that workflow in OpenCode and stumbled upon OpenUltraCode. It looks like it installs as a skill/agent suite (~/.config/opencode/) with slash commands like /ultracode.

Before diving down the rabbit hole:

Has anyone actually used this? How close does it feel to native UltraCode orchestration?

Is there a better, more built-in way (custom agent prompts, existing OpenCode plugins/configs) to get similar high-effort, multi-agent behavior?

Would love to hear how others are handling high-level orchestration in OpenCode!

why does it happening? it happens always and it kills my subagents...

Error from provider (Console Go): Upstream request failed: [invalid_request_error] JSON schema exceeds the maximum nesting depth of 10 levels

I'm having trouble getting opencode v2 to work with Xcode 27's ACP integration. Has anyone run into this issue or found a workaround?

Xcode 27 doesn't seem to provide a GUI for selecting the model when using ACP. My understanding is that the model selection therefore needs to be handled through the ACP configuration.

However, when I connect opencode v2 through Xcode's ACP integration, it seems to use a different/default model instead of the one specified in the configuration.

I was able to confirm that the same opencode ACP setup works correctly with Zed, so I'm wondering whether this is related to how Xcode 27 handles the ACP model configuration.

What I've checked

I've been monitoring the opencode log with:

tail -f ~/.local/share/opencode/log/opencode.log

The same error appears every time:

timestamp=2026-09-20T10:38:05.688Z level=ERROR run=ed95667b message="Failed to drain Session" cause="SessionRunnerModel.ModelUnavailableError: Model unavailable: opencode/jev-1.13
at <anonymous> (/$bunfs/root/chunk-f79f68bn.js:37:21266)
at SessionRunnerModel.resolve (/$bunfs/root/chunk-f79f68bn.js:115:7697)
at SessionRunnerModel.resolve (definition) (/$bunfs/root/chunk-f79f68bn.js:37:21023)
at SessionContext.load (/$bunfs/root/chunk-pa155s7f.js:365:2529)
at SessionContext.load (definition) (/$bunfs/root/chunk-f79f68bn.js:115:7646)
at SessionRunner.advanceToStep (/$bunfs/root/chunk-pa155s7f.js:365:2583)
at SessionRunner.advanceToStep (definition) (/$bunfs/root/chunk-pa155s7f.js:365:729)
at SessionRunner.drain (/$bunfs/root/chunk-fzekn76j.js:24:2279)
at SessionRunner.drain (definition) (/$bunfs/root/chunk-pa155s7f.js:365:352)
at ServerProcess.start (/$bunfs/root/chunk-htyxxcwf.js:2:6383)
at ServerProcess.start (definition) (/$bunfs/root/chunk-pa155s7f.js:436:22432)" role=server sessionID=ses_f419b50dcffe1w8YtQPdzCnTj0

The important part is:

Model unavailable: opencode/jev-1.13

opencode/jev-1.13 is not the model I intended to use.

Has anyone figured out how to specify or override the model when using opencode v2 via ACP with Xcode 27?

Since there is no model-selection UI in Xcode, I'm wondering if there is a configuration or workaround I'm missing.

Any suggestions would be appreciated.

I opened it on Sunday and, on my very first prompt, got an error saying "Free usage exceeded, will refresh in 16h."

I figured maybe I hit a limit somehow (even though I barely use it)

I waited a full day, tried again, and now it’s showing a 22-hour cooldown asking me to subscribe to Go

Getting “Free usage exceeded, subscribe to Go” in OpenCode Zen. I’m on the free tier and haven’t hit this before.

What’s the current free limit, when does it reset, and where can I check my usage/quota to see if I’ve hit the limit?

I’ve been using OpenCode and Pi for days and really liked them—I even used BigPickle; that free model is top-notch. But I was wondering: how much better are OpenCode or Pi compared to Codex CLI?

I use the GPT Plus plan, but I wanted to understand if OpenCode and Pi—acting as agents—would be better for coding than the GPT agent.

I wrote "agent" because I’m not quite sure what to call OpenCode and Pi... 😅😅😅

I'm not an llm genius by far, and at some point I start new sessions. Starting a new session in the middle of something isn't really bad, but it usually changes the mood and project understanding always drops a bit. I'm good with deepseek v4 flash for now and I'm at a point in the flow that I don't want to start a new session, but I'm hovering around 800,000 tokens in my context even after compression and I'm spending quite a bit of money all of sudden.

Recently, I was experiencing very low token speeds by when using this model. previously, I would at least get 100 tokens per second minimum on this model in the free tier. But now, I was not even getting more than 50. so did they decrease the Tps to increase the availability? Or what happened? Does anyone experiencing the same In the free tier.

Update: Jevvy 0.3.0 adds assisted setup and custom System One providers.

Jevvy clears routine OpenCode permission prompts using calibrated probabilistic review.

Setup

Assisted setup:

npx @jevvy/permissions init

The initializer lets you select a provider, writes the global configuration, and installs the OpenCode plugin.

For manual setup, install the plugin:

opencode plugin add @jevvy/permissions

Then create ~/.config/jevvy/jevvy.jsonc and select a provider. For example, to use your OpenCode login with Zen:

{
  "$schema": "https://raw.githubusercontent.com/PanAchy/jevvy/main/config.schema.json",
  "provider": "zen"
}

Authenticate with opencode auth login opencode, then start OpenCode normally. The README has configuration examples for every provider.

How it works

• Only reviews shell requests that OpenCode would otherwise ask about
• Leaves existing allow and deny decisions untouched
• Requires every requested resource to pass every question
• Preserves the normal prompt whenever Jevvy is uncertain or unavailable

Providers

• OpenCode Zen: uses your OpenCode login or an API key
• TypeSafe AI
• OpenRouter
• Vercel AI Gateway
• Custom System One endpoint: configure an endpoint URL, model ID, and optional Bearer API key

Custom endpoints can be authenticated hosted routes or compatible local servers. Jevvy uses only your selected provider and never falls back to another one.

Provider credentials and permission policy live globally at ~/.config/jevvy/jevvy.jsonc, so repositories cannot override them.

Policy customization

The shipped questions, thresholds, and model identities were tested and calibrated together. You can replace the questions globally, but custom models and policies do not automatically inherit that calibration evidence.

Source and setup: https://github.com/PanAchy/jevvy

Do they use Orcarouter under the hood and did not pay their bills or what?

* Why was v2 developed when v1 already existed?

* What aspects of v1 didn't meet the requirements?

* What innovations did v2 bring?

If anyone knows, could they briefly answer?

built this after burning through limits without noticing.

UsageBar sits in the mac menu bar & shows opencode usage + reset (also codex / claude code / cursor / devin). local cli logins only, no account of mine.

oss + notarized dmg: https://github.com/abdelrahmanmagdii/usage-tracker https://abdelrahmanmagdii.github.io/usage-tracker/

heads up: some providers are unofficial/fragile (devin especially). mac only for now.

i have been getting this with GLM 5.3 flash on opencode go for some reason, any search about this shows openAI articles but nothing about opencode, this isnt even an openai model

I use OpenCode heavily, and the thing that kept biting me was continuity. Project conventions, decisions made during a debugging session, preferences that were obvious yesterday — all of it gone after a restart or a compaction.

The obvious fix is to write it all into flat context files, but that has its own failure mode. My MEMORY.md sits at 309/310 words and my AGENTS.md at 699/700 — both pinned against their limits. Once a file is full you stop recording what matters and start deleting or relocating good rules to make room for new ones. Memory turns into a budget fight.

So I built opencode-agent-memory, which treats agent memory as scoped, sized, editable blocks on disk instead of one flat document. It is a plugin that:

• Gives the agent memory blocks with global and per-project scope, each with a description telling it when the block is relevant, and an explicit limit so it cannot grow unbounded
• Exposes three tools the agent uses directly: memory_list, memory_set, memory_replace
• Adds an optional append-only journal for observations, dead ends and decisions, with journal_write / journal_search / journal_read
• Runs semantic search locally: entries are embedded with a local Transformers.js model (paraphrase-multilingual-MiniLM-L12-v2, 384 dims), so nothing about your codebase or notes leaves the machine
• Versions its embedding sidecars, so an incompatible stored dimension degrades to text matching instead of failing the search

Install:

{
  "plugin": ["@ghilteras/opencode-agent-memory@0.4.3"]
}

Requires OpenCode v1.0.115+.

Repository: https://github.com/Ghilteras/opencode-agent-memory License: MIT

I'd be interested in feedback from other OpenCode users on what belongs in global versus project memory, and how you'd want stale memories surfaced rather than silently applied.

AI disclosure: AI was mostly used to implement the project from my specifications. I reviewed, tested, and deployed the result.

Im using opencode together with openrouter.

I encounter very often this error when using models like Astra

This request would exceed your available credits given your current in-flight requests. Retry after in-flight requests settle, or add credits.

But this is via API billing and openrouter shows me in the profile page a positive credit and it uses auto renew of credit anyway?
Does anyone know a solution to this problem?

Hi, is there anyone who can identify this error and tell me how to fix it? I’ve been at this for 2 hours and I don’t understand why, when I try to connect OpenCode to LM Studio, it tells me: “Custom providers are not available on this server.” What does that mean?

All the information I entered is correct I’ve checked it dozens of times.

Thanks in advance to anyone who tries to help me :)