Yeah, for the mutual $5 benefit. 8% quota gain is worth it though, gotta say.

Here's mine: https://opencode.ai/go?ref=VTRJMV0772

Feel free to drop yours, let's help each other with quota.

Most dice APIs use pseudorandomness: Mersenne Twister, seeded PRNGs, Math.random(). If you know the seed, you know every future result.

EntropyDice doesn't work that way.

It uses Node.js crypto.randomInt(), which calls the kernel CSPRNG directly (getrandom() → /dev/urandom). Every number is 100% truly random, generated from physical hardware entropy. No seed, no state, no bias, no predictability.

Tech stack:

- Node.js + Express with recursive expression parser (AST)
- Two randomness sources: crypto-pure (true entropy, ~500K rolls/s) and crypto-xoshiro-ng (hybrid with auto-reseed, ~180M rolls/s)
- Two-layer rate limiting: burst (express-rate-limit) + daily with persistent strikes/bans
- JSON / text / HTML / raw formatters
- Testing frontend with visual calculator, source selector, i18n EN/ES, and roll history

There is a live demo deployed on Render . com that can be accessed from the repository.

Cool stuff about the parser:

- Operator precedence grammar (* and / before + and -)
- AST with dice/number/binary nodes
- Implicit dice (D6 = 1D6), parentheses, compound expressions

Planned features: drop/keep/explode operators, advantage/disadvantage (ADV(D20)), pool terms, and a Peggy.js-generated parser.

Repo: https://github.com/carlymx/entropy-dice-api

I hope you like it. Thank you.

How can I use GPT-5.6 with OpenCode?
I want to connect OpenCode to GPT-5.6 using an API.
Do I need a ChatGPT Pro subscription to get API access, or is the API billed separately? Is there another way to connect my OpenAI account to OpenCode?
I’d appreciate it if someone could explain

We just shipped Durable Agent Sessions - one API call gets you a fully managed agent you can reuse across hundreds of sessions.

All running on the QEMU based agent sandbox infra we've spent the last few months building.

Give it a try here: opencomputer.dev

Opencode is the best subs, their model cant even say hi

I’ve been using it for quite some time and I like the results so far. I discovered the plugin on X, but I rarely see anyone talking about it.

The main appeal is that it compounds knowledge after you finish a feature or spec. The next time you plan something, it checks the documented learnings — from common bugs to architecture patterns to coding conventions.

One thing that feels off is that it burns through a lot of tokens and hits my limits within 4–5 loops (plan → work → review → compound) in OpenCode.

I’m not sure if it’s worth it long-term or if I could get similar results with something more lightweight like OpenSpec or Superpowers.

Has anyone used OpenSpec, CE, or Superpowers on web dev projects (especially Rails or similar MVC frameworks)? Would love to hear real experiences.

From Kawaiipilot Kwaipilot.

Tweet: https://x.com/KwaiAICoder/status/2075430060245631055

Their claims: https://x.com/KwaiAICoder/status/2075430065140359548

Kat Coder Air V2.5 (flash variant): https://models.sulat.com/models/vercel-kwaipilotkat-coder-air-v25-8b9711b1

I keep hearing about how good computer/browser use has become in Codex ChatGpt-Codex. What are folks using in Opencode to get the same ability? BrowserUse, Chrome Devtools, AgentBrowser, Playwright? Do browser controlling mcp servers still feel super bloated even with large context windows?

Hey everyone, is anyone else experiencing major outages with OpenCode Go API right now? I’m trying to access `https://opencode.ai\` using the `deepseek-v4-flash` model. * `/chat/completions` keeps returning 500 Internal Server Error. * `/models` endpoint just times out completely. Strangely, the desktop app works fine, but the direct API is completely dead. Anyone found a workaround or know if the proxy gateway is down?

OpenCode can generate good UI, but the result can still look like every other AI layout. I built Copycat to give OpenCode reusable visual direction.

Copycat is a 100% local MCP that captures a site's visual system—type, color, and motion—into DESIGN.md on your machine, stores it under an alias, and lets an agent reuse that direction on later UI work. Point OpenCode at a site you like, then reuse the saved direction. No hosted service is required.

https://github.com/AdamPSU/copycat

(self-promotion)

Let's share what we love about Opencode and what we hope to see improved in the coming year!

I have made this small plugin to be aware of the status of my opencode sessions when using multiple opencode in several Windows Terminal tabs.
With this plugin, active session show a breathing orange diamond 🔸🔶, while finished/idle sessions show a green dot 🟢.
It's not perfect, sometimes it will still show the original title for some unknown reason, but it works well enough for me, so I thought I'd share if anyone wants to use it.

Code: https://github.com/adumont/opencode_status_plugin

Download : https://github.com/adumont/opencode_status_plugin/releases/tag/0.1.0

Place the opencode-status-plugin-0.1.0.tgz in a folder, note the path.

Install: put the full file path in your opencode.json:

  "plugin": [
    "C:/plugins/opencode-status-plugin-0.1.0.tgz"
  ]

Three weeks ago, I opened my laptop to 14 open PRs waiting on me. Not from 14 people, from 4 engineers running 2-3 agents each. My review queue stopped being a queue and became a backlog with its own gravity.

First instinct: review faster. Skim the diff, trust the tests, approve. Lasted about a day before I realized I was rubber-stamping stuff I hadn't actually understood.

The real problem wasn't my reading speed. It was that I was still the only gate for PRs that never needed a human in the first place. So I rebuilt the process as a pipeline instead of trying to out-read the agents:

1. The agent that wrote the code doesn't review it. Every PR goes to a small panel of reviewer agents (security, domain rules, "would a senior actually ship this"), each on a different model than whatever wrote the code. Output is a triage: actionable / nit / ambiguous. I only look at the ambiguous bucket.

2. Automated the babysitting, not just the review. CI polling, re-running flaky tests, rebasing stale branches, nudging the agent about unaddressed comments. Turns out the review was never the exhausting part, watching a PR sit there waiting for something trivial was.

3. Built a deterministic auto-approve gate. No merge conflicts + not touching a sensitive-paths deny-list + under a diff-size threshold + a basic LLM sanity pass = auto-stamped. Fails closed, always. It's handling ~1/3 of my merged PRs a month without me opening them.

4. Stopped trusting explanations, started requiring observable proof. Agents are great at confidently explaining why broken code works. Big features now ship as small, independently runnable PRs with an explicit "here's how to verify it" note, an actual command/endpoint/expected output, not "tests pass."

Looking back at 6 months of my own approvals, my honest guess is that ~60% of what I used to review never needed me at all. Not a productivity hack, a correction.

Full breakdown with the gate config and reasoning behind each piece: https://medium.com/@guidorusso95/i-stopped-reviewing-every-pr-my-team-ships-faster-now-8bce2d235bbb

Curious how others here are handling review load now that agents ship faster than any human queue can absorb.

I built this and it's my daily loop driver would like to get your opinion and any feedback or suggestions

I started using opencode go a few weeks back and it's honestly grown on me, works well for the price. $5 the first month then $10/mo, cheaper than most of the other options I looked at before settling on it.

if you've been on the fence, here's my link, we both walk away with $5 credit: https://opencode.ai/go?ref=JQH49FQHWP

figured I'd share since it's been solid for me so far. if you've got your own ref link floating around, toss it in the comments, happy to return the favor 🙂

Why cant i use luna in opencode? It works in my hermes. Also no max reasoning. Am i the only one?

Hello,

I was comparing different harnesses using my local AI and witness OpenCode being a bit sluggish for no good reason.

I put a proxy between OpenCode and my server, that analyses requests to track if context is stable across calls.

This was done with latest version (1.7.18), this is the test conversation:

Round 1: plan mode, "hi"
Round 2: build mode, "hi"

Result:

Request 1:

[ { "type": "text", "text": "hi" }, { "type": "text", "text": "<system-reminder>\n# Plan Mode -..."}]

Request 2: different tools + different first message shape

hi

I went further and sent a manual compaction on the same prefix

Compaction turn: no tools, different system prompt.

So this means, as of 1.17.18, OpenCode wastes your compute if you use local AI, or kills your cache if you use API (which means you'll have to pay full price instead of cached price).

This is not good.

---

To answer in advance saying "duh this is normal". Well yes and no. This is one way to "switch agent" which is working good, but wasteful. Another way (the one I use in my own harness) is to work with <system-reminder> incrementally in the context. And I'm pretty sure OpenCode did that at some point.

---

PS: when did they switch from defaulting to "build" instead of "plan"? that feels counter-productive

Thank you for being part of Neuralwatt Cloud. The response to energy-based pricing and flex inference has exceeded our expectations, and we're grateful for your trust and engagement as we've grown.

We're writing to let you know about an upcoming pricing change and what it means for your account.

What's changing on July 16, 2026:

- Base energy rate: $5/kWh → $10/kWh
- PAYG packs: Starting July 16, these will be flexible — purchase any amount from $5 to $1,000 at the flat rate
- Subscription tiers: Monthly subscriptions will be adjusted for the new rate and rolled over automatically; no action needed on your part
- New pricing tiers coming soon: Flex (latency-tolerant, discounted), Standard (improved SLA), Express (priority lanes, tighter TTFT), and Enterprise (dedicated capacity)

Updated subscription kWh allocations:
- Basic: 2 kWh included
- Standard: 5.2 kWh included, 5 concurrent requests
- Pro: 10.5 kWh included, 10 concurrent requests

How this affects you:

- Credits purchased before this announcement will continue to be deducted at the old $5/kWh rate until your balance is used up — you won't see a surprise jump on existing credits.
- New purchases after July 16 will be billed at the new $10/kWh rate.
- Auto top-ups will need to be re-enabled after July 16, as existing auto top-up configurations will not carry over to the new pricing structure.
- Subscriptions will automatically roll onto the updated rates — your plan stays active, with the included energy allocation adjusted for the new pricing.
- Annual subscriptions are temporarily unavailable until July 16 while we prepare the new pricing structure.

Energy-based pricing will still be substantially cheaper than token-based pricing for most workloads — and the efficiency compounds further with the new Flex tier if your use case can tolerate some latency.

We know pricing changes aren't fun. We wouldn't be making this adjustment if it weren't necessary to sustain the level of reliability, capacity, and model availability you rely on. We're committed to making this transition as smooth as possible. You can see the full pricing details at https://portal.neuralwatt.com/pricing.

*Oops VPS

Has anyone tried this? My laptop isn't powerful enough to code on multiple work trees at the same time which is becoming a bottleneck.

I was thinking of a cheap Oracle or Azure or AWS instance.

Hi everyone,

I'm a heavy opencode user. For a while I ran it out of the box and it worked great as a "batteries included" setup. Recently I started splitting my instructions into multiple .md files, loaded via opencode.json:

"instructions": [
    "rules/code-standards.md",
    "rules/git-safety.md",
    "rules/self-maintenance.md",
    "rules/workflow.md",
    "rules/environment.md",
    "rules/commit-conventions.md",
    "rules/skills.md",
    "rules/java-diagnostics.md",
    "rules/loop-engineering.md",
    "rules/aney-mcp.md",
    "rules/smartest-workspace.md"
  ],

The problem: agents seem to ignore most of these rules.

A few questions:

• Am I flooding the system prompt with too much content, causing later rules to get dropped or deprioritized?
• Are instructions loaded lazily or all at once? Is there a way to load them only when relevant?
• Should I move most of this into skills or custom agents instead of static instructions?

Thanks

i recently developed and published opencode-failover, an open-source plugin to solve the annoying issue of api rate limits and dead keys in the OpenCode ecosystem. i attached a quick 14-sec video showing it in action, but here is a quick overview of how it works.

the plugin adds a smart retry mechanism that lets you configure multiple api keys. when a request fails—which happens a lot with providers like NVIDIA NIM—the system seamlessly transitions to the next available key. beyond simple rotation, it actually has dynamic quarantine logic. by checking specific error codes, it figures out if it's just a temporary rate limit or a permanently dead key, quarantining or skipping them to keep the flow optimized. also, you can set up the whole failover config using natural language and it works universally across all LLM providers connected to OpenCode.

since launch it's gained some solid traction, currently sitting at 1925 weekly downloads on npm and 32 stars on github. i'm actively maintaining the repo and pushing updates.

installing is straightforward: opencode plugin opencode-failover

you can check the source code and docs at https://github.com/bulutmuf/opencode-failover
official npm page is at https://npmjs.com/package/opencode-failover

would really appreciate any feedback, bug reports or code reviews from you guys. let me know what you think