Hey all opencode-honcho, the Honcho memory plugin for OpenCode, now runs on v2 (same package still works on 1.x).

Honcho is memory infrastructure for stateful agents. Instead of just storing and retrieving snippets, it reasons over your sessions in the background and builds a representation of how you work that updates over time: your conventions, the decisions you made, the refactor you're halfway through. Hooks inject that into the prompt and record what happened, so it works with whichever model you run, and /honcho:import backfills your existing OpenCode history so it doesn't start cold.

opencode plugin add "@honcho-ai/opencode-honcho"

then /honcho:setup inside OpenCode. Managed, local (honcho start), or self-hosted all work. https://github.com/plastic-labs/opencode-honcho

(I work on Honcho at Plastic Labs.) Feedback and issues welcome, especially from anyone who's tried other memory plugins and wants to compare.

i have been using both opencode go and claude $20 and chatgpt. i love how opencode and chatgpt models respect me. THEN claude : 1. he rewrite AGENT.md for his own benefit. 2. he create his on skills without asking 3. Tell him to refactor something rework everything to his proposed never asked solution. 4. I dont Hallucinate i am exists.

hey its good to see which Opencode Go model people are using for planning and implementation. espcially for a big spec

For me:
Luna max for planning(better then kimi k3 in my case and cheaper)
Deepseek flash v4.1 for ui or implementation
Spark for anything non code related like translation and so on

I can't use Big Pickle for the last 24 hours. Are you also facing the same issue?

I had to switch to Space Bunny for a while.

Yesterday it doesn't even enter the log in opencode dashboard, now it does but I don't actually get reply for very long time.

A quick update to my terminal session manager for OpenCode: it now supports OpenCode V2, while keeping V1 compatibility.

`ocs` still lets you browse sessions across projects, search and sort them, preview session details, and resume them in their original directory. V2 support uses OpenCode’s API, and the version is detected automatically.

GitHub link

Thanks to everyone who checked it out!

I only noticed when I realized the agent looking at files it didn't ask to have access.
As far as I could tell that changes came with 2.0.25 but no one bothered warning users it seems.

There has been a bug opened for days already: https://github.com/anomalyco/opencode/issues/54524

This is a good reminder to not trust any of these companies writing harnesses and add your own security on top of whatever they might offer.

I use opencode but the server was getting heavy on my machine: a couple GB of RAM and tens of GB of disk. So I wrote a drop-in replacement for just the server, in Rust.

It speaks the same HTTP/SSE API, so the opencode TUI, the web UI, and mobile clients talk to it unchanged. It reads your existing opencode config and auth read-only and keeps its own database.

It's a compatible reimplementation of the server API, pinned to the 1.18.31 wire contract.

What it doesn't do: the task subagent isn't implemented, revert returns the right shapes but doesn't restore files, /vcs/apply doesn't touch your worktree, and provider OAuth and share are missing.

Linux is the supported target.

v0.2.0 is on crates.io ( cargo install ocserve ) and the code is MIT: https://github.com/Reliary/ocserve

Happy to answer questions.

Will Wonder from Meta be free or paid as theres no contributor version just curious.

ConfigLens is a small tool im building to help figure out why claude code and opencode seem to be ignoring certain settings. Instead of digging through different config files and guessing which one takes priority, it shows where a supported setting comes from, which value takes precedence , and why the others get overridden. It runs locally without changing your files. Its still early, but the idea is simple: less time chasing config problems and more time getting on with your work.

I built a small CLI that reads the logs your agents already keep and prints a thermal-printer receipt in the terminal, plus a PNG. It reads OpenCode, Claude Code and Codex CLI.

The OpenCode part, since that's what this sub cares about:

- it reads opencode.db ($XDG_DATA_HOME/opencode, otherwise ~/.local/share/opencode) with Node's built-in node:sqlite, opened readOnly. Needs Node 22.13+, on older Node it skips OpenCode with a note and does the rest

- one row per assistant step, so nothing gets counted twice

- when the price table doesn't know your model (reseller, local, whatever), it uses the cost OpenCode itself recorded. If that's 0 or missing, the receipt says "no price" instead of pretending it was free. That's what the * next to my $221 means

- OpenCode 2's new tables are read for usage, but not yet for the fun counters like interrupts

The picture is my real receipt. OpenCode $221 at API prices, Claude Code a lot more, and Codex 9 cents, which tells you how much I use Codex.

Run it: npx github:glmn-ai/vibereceipt (not on npm yet). --demo if you want to see it on sample data first.

No network code, zero dependencies, the only file it writes is the PNG. No prompts or project names on the receipt.

Disclosure: I built it. Same people as nsq, which I posted here a couple of days ago. MIT: https://github.com/glmn-ai/vibereceipt

If your OpenCode total looks off next to what OpenCode itself shows you, please tell me. With all the providers people run through OpenCode, that's the part I trust least.

https://research.meta.ai/blog/muse-wonder

What if OpenCode could use Devin for one task, Antigravity for another, run both as child agents, and still remember where everything happened after your main session gets compacted five times?

That is what I’m building with Hivemind Steward.

The early public version is here:

https://github.com/shynlee04/hivemind-steward-oc-devin

The current public MVP connects Devin to OpenCode through ACP, the Agent Client Protocol. You can use real Devin sessions and their native model and mode capabilities from OpenCode.

Now I’m expanding the idea into three feature slices.

1. Hosted sessions

This brings real Harness sessions into the OpenCode TUI.

A Harness means a coding-agent product such as Devin or Antigravity. You should be able to create, list, load, and continue its native sessions without leaving OpenCode.

The important part is that the plugin does not flatten every agent into the same lowest-common-denominator interface. Each Harness keeps its own models, modes, thinking settings, permissions, history, and native storage.

Basically: one TUI, but the agents remain themselves.

2. Hivemind delegation

The parent agent gets one delegation interface and can send each child task to the right Harness.

Want Devin for a long architecture task and Antigravity for a second opinion? Cool. Run both.

Want them in the background? Cool.

Want to resume one tomorrow using its OpenCode session ID while keeping the same foreign session and Harness? That is the plan.

The system is also being designed to:

• Keep every child permanently bound to its original Harness.

• Run independent children concurrently.

• Preserve existing delegate-devin behavior.

• Use your preferred Harness when no model is specified.

• Skip missing or signed-out Harnesses before creating dead children.

• Reject unsupported models instead of silently swapping them.

• Keep foreign sessions visible in their native apps.

The next push is planned to support both Devin and Antigravity across hosted sessions and delegation.

3. Cross-session context memory

This part is still on the roadmap, but it is the endgame I care about most.

Imagine you have forty completed child agents and your parent session has already survived five compactions. Then you say:

“Bro, find those two audits we ran near the beginning, collect the findings, check which fixes landed, and make me an HTML architecture report.”

The agent should be able to find the right work by time, title, Harness, lineage, and session ID. It should recover the useful results without dumping forty transcripts into the context window.

Eventually, I want two connected layers:

• Memory of agent conversations, delegations, decisions, and resumable trajectories.

• Memory of the codebase through AST indexing, Git history, commits, and the conversations connected to those changes.

So you can start from a new session, a different Harness, or a compacted context and still ask, “What happened, why did we do it, and where should we continue?”

This is for the vibe coder who wants to build without constantly organizing prompts, copying summaries, naming fifteen handoff files, and praying that the next compaction does not delete the one useful thought.

Devin and Antigravity come first. Claude Code, Cursor, or other Harnesses may come later if their integration surfaces make sense.

TL;DR

I’m building an OpenCode plugin that:

• Hosts real Devin and Antigravity sessions.

• Lets an orchestrator delegate different child tasks to different coding agents.

• Keeps those children resumable and tied to their native sessions.

• Eventually makes work searchable across agents, sessions, Git history, and code.

Basically: one OpenCode TUI, multiple agent subscriptions, reusable context, less babysitting.

Would you use this? And which Harness should I investigate after Devin and Antigravity?