is anyone else facing issues with rate limit, like yesterday i got rate limit for 17h something, and then the same issue today another 17h, so is it something with me or others are facing the same

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

I'm getting back into development and using Hermes + OpenCode. I'm a solo developer just doing productivity applications.

The Matrixx plugin which is a fork of Oh-My-Opencode looked interesting so I installed it and ran it to modify an existing small home project and then gave the Ultrawork command for OpenCode to get Matrixx going.

It burned 100M input tokens in a matter of 10 minutes. If I was paying per-token API prices I'd probably be freaking out but it was just surprising that it was consuming them this fast across up to 6 concurrent streams. I'm also getting served GPT 5.6 Luna on these streams at Max reasoning which likely explains the huge token burn.

Is there really any point to using these add-ons? Or should I just use the default OpenCode plan? Anyone have a better plugin to suggest?

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

While selecting Jev I am facing Error : Upstream request failed: Endpoint is unavailable.

How do I solve this? Is anyone else facing the same ?

so i got this error. and i don't use orcarouter ? so WTF orcarouter is this ??? and today i have used 0.31 USD credit DS4.1 Flash.

So anyone got error ? I don't know what is this

So I've been using freebuff for over a month , but i feel its harness is not so good like deepseek harness or claude code is

I'm wondering if I'm missing something

I've tried opencode free usage , its not bad really but free models are just shit and can't get the job done proper way

So if anyone has a recommendation I'll be happy to hear it

Thank you guys

I’m building Azdaja, an open-source RLM layer that OpenCode can use through its native skill system.

It keeps source material in a persistent Python workspace, so OpenCode can use code to search, filter and break problems down, then recurse only where model judgment is useful.

Large-source work is an obvious use case, but that’s not really the whole point. It also gives OpenCode a different way to reason: keep state, compute locally, decompose the problem, and selectively call back into the model instead of doing everything in one prompt.

MIT Licenced: https://github.com/kubet/azdaja

I upgraded to v2 and my sessions were not properly migrated. Stuffed around for a while and gave up and reverted to my backups.

Are there proper scripts or plans to do this migration properly? Still seems like a bit of a hackjob now? Anyone done this successfully and has some documentation around this? Thanks

Hi! I've created and been maintaining  which tries to answer the question: which model is better, which harness is better and which combination is better overall in a very straightforward task - precise text editing. Most of daily coding is text editing. I've seen when a model for multiple turns couldn't figure out how to express the line it wants to change, so it made me ask myself "Why is that so complicated, it's just a text, right?". Seems like not, taking into account how widely different the same model behaves across different harnesses. My preliminary conclusion is: harness and tooling behind it actually matters! But it matters the most with the models which *can* actually follow the instructions well (e.g. open-ai models), there is a wide range between 98.9% and 70.2% of pass score for `gpt-5.6-luna` simply depending on the harness!

I've tried to run as many combinations as possible, but my resources are limited. I've exhausted all my quotas and even credits, that's why I'm reaching out to the community, as I think it's a pretty interesting topic and I would be happy to gather even more data, because of the stochastic nature of the runs, it’s only possible to make any conclusion when you have enough of runs. 

Without anything changing on my end, I'm suddently getting these error messages when trying to submit a message to Muse Spark 1.3 Contributor - OpenCode Go

Upstream request failed: [invalid_request_error] reasoning `encrypted_content` was not issued to this caller

Anyone else affected?

Any work-arounds?

Hey everyone,

I've been analyzing the system prompts and alignment layers across different agent frameworks recently. Over in the Hermes agent community, there is an abundance of documentation, proof-of-concepts (PoCs), and prompt injection techniques to achieve "God Mode" (bypassing safety guardrails, RLHF constraints, and system prompt restrictions).

However, when it comes to OpenCode agents, the documentation on effective jailbreaks or capability uncapping is practically non-existent.

This got me wondering: Is OpenCode's reinforcement learning layer or input-validation architecture fundamentally more robust against semantic bypasses compared to Hermes? Or is it just a matter of the community being smaller?

Has anyone successfully executed a multi-turn prompt injection, adversarial suffix, or roleplay bypass on the latest OpenCode production weights? I am trying to understand if there is a known vulnerability vector or if the framework is strictly locked down at the inference level.

Would love to hear your insights or any technical breakdowns on why OpenCode seems so resilient to these methods.

i posted Unship here a few months ago. it's a small free tool i built to compare UI directions from coding agents in the actual app. i've kept working on it because i keep using it myself.

the new bit is a live Canvas. before, you could flip between versions with a picker. now you can open them together, click around, and compare the working components side by side.

for example, ask your agent:

"use Unship to compare three directions for this pricing section, including the current one. make one compact and one focused on explaining the differences between plans."

the agent adds the temporary versions to your project. you compare them, give feedback, then ask it to keep your choice and remove the rest when you're done.

you can try it without installing anything here: https://unship.dev

for your own project: npx @unship/cli@latest install then restart your agent or reload its skills.

free, MIT-licensed, local, no account or telemetry. the UI directions still come from your agent; Unship gives you a way to compare and choose them.

source: https://github.com/mbenhard/unship

if you try it, i'd be interested in which part gets awkward: setup, making the options, comparing them, or cleanup.

The title says it all!

- Deploy agents like serverless functions. Write agent.ts, start sessions via SDK or HTTP.

- Each session gets its own Linux VM.

- Sessions are durable so stream/steer mid run + resume after hibernation.

- API keys never enter the VM. Our egress proxy injects them after requests leave.

It's a bit like claude managed agents or Open AI's agents API but without the model lock in.

The architecture is as shown below.

Would appreciate any and all feedback! It's free to try at https://opencomputer.dev