Do you know why it's not implemented yet?

Or are most of you only using it with set skills

Between work and hobby projects I use Claude Code, Codex CLI, Kiro and OpenCode — I like all of them and often switch between them depending on their strengths and availability. The problem, though, is always the same: every session starts from zero, and each agent has its own config scattered across different files (.claude.json, .codex/config.toml, separate global skills, separate global hooks...). Neither of these two things — memory and configuration — survives across sessions or propagates to the rest of the team.

The starting idea is Karpathy's "LLM Wiki": an agent shouldn't be doing stateless RAG over a pile of static documents, it should have a wiki it builds and curates itself over time, session after session, the way a human takes notes while working. The problem is that if you let an agent write markdown files freely, sooner or later it breaks something — dead links, concurrent writes overwriting each other, lost context.

I wrote Cartographer to solve this: an MCP server in Go where the agent never touches the files directly, it only talks to MCP tools, and the server enforces the invariants server-side (validation, one git commit per write, automatic lint for broken links/stale claims, conflict handling on concurrent writes).

But the part I think is strongest for teams is another one: the KB doesn't just hold knowledge, it also holds skills, hooks and operational instructions, and the client (cartographer connect) automatically materializes them in the native format of whichever agent is installed — Claude Code, Codex CLI, Kiro or OpenCode. In practice:

• you write a skill or a hook once, in the shared KB
• every team member runs cartographer connect (or sync when something changes) and gets the skill/hook already registered in their own agent's native mechanism — settings.json for Claude, config.toml for Codex, etc.
• cartographer status immediately tells you if you're drifting from what the KB is distributing

So it's not "just" an agentic wiki: it's a way to keep an entire team of heterogeneous agents (different agents, different providers) aligned on the same knowledge base and the same operational behavior, with a signed audit log and everything revertible via git underneath.

Under the hood: OKF (Open Knowledge Format by Google Cloud) as the format, so zero lock-in — it's just markdown + git, also openable with Obsidian or any text editor.

This is my first open source project, and I'm still learning a lot along the way — but if you feel like trying it out, it'd mean a lot, and if you like it a star on GitHub is always appreciated. It's still all pre-1.0 beta, so expect rough edges, but I think it has some potential: if you have opinions, criticism or ideas, feel free to leave them in the issues, any feedback is welcome.

github.com/BeppeTemp/cartographer

Hy3 has been added to OpenCode Go. Looks like it might be a good, cheap workhorse model.

Here's the official release page, which has a lot of benchmarks: https://hy.tencent.com/research/hy3

According to Artificial Analysis, it benches around the same as Kimi K2.6 and DeepSeek V4 Pro.

The usage limits on OpenCode Go are pretty generous:

Has anybody here tried it out? What are your thoughts? I'm looking forward to seeing how well it works.

Hi,

So I am a new suscriber to the Go plan and today I started a session. When I was done, on the right side of the CLI y can see:

Context:
131, 342 tokens
13%
$2.43 spent

But after checking the web dashboard, I see:

So it seems that I've spent around $9.24 (because $12 is the max for 5 hours, right?)

What is the reason for this difference?

Thanks in advance!!!

Today an AI agent trying to browse the web is like a thief in a balaclava sneaking around a police academy. Site protections block it, challenge it, turn it away.

browser-search flips the script: your agent stops being the thief and becomes the chief of police. No more clumsy access attempts. It walks through every door because it has the right tools. SearXNG for search, Camofox for browsing, CloakBrowser when things get tough.

100% self-hosted, free, no limits, no API keys.

I just released v2.0, whose core logic enforces the exclusive use of deterministic scripts. This eliminates model hallucinations, even with the cheapest models. The skill describes the 3 tools in natural language, but execution is rigid: the model can neither get the command wrong nor misinterpret the output. The result is guaranteed success on every query — the skill and deterministic scripts guide the model to scour the web until it finds the answer.

No more excuses. Your agent has the badge now.

https://github.com/Johell1NS/browser-search

The most annoying part of using opencode (or any AI coding harness) is watching it start every single session with zero memory of what happened yesterday. A session ends, compaction wipes the slate, and two days later you're watching the agent re-learn the exact same obscure bug fix from scratch. You either burn tokens repeating yourself or manually dig through old transcript files.

I built deja to fix this offline.

It reads your local opencode.db directly and indexes past sessions with zero external API keys, zero LLM calls, and no background daemon eating RAM. It’s just a single Go binary that wakes up on a hook, responds in milliseconds, and dies.

For opencode specifically, a small deja.js plugin injects a digest of relevant past work at session start before you even type your prompt. The agent can also query its history mid-task using MCP tools (deja_recall, blame, remember).

Two features made the biggest difference in my daily workflow:

First, handoff between sessions and tools. The index is shared across 12 harnesses (opencode, Claude Code, Cursor, Codex, Grok etc.). What you fixed in Claude Code yesterday is immediately recalled by opencode today, so you don't lose context when switching tools.

Second, peer-to-peer machine sync. Running deja sync ssh <host> moves new memory between your devices using your existing SSH setup. An agent can grind on a headless mini overnight, and in the morning I pull its memory to my laptop so the local agent instantly knows what was tried, what broke, and what worked. No cloud memory service involved.

Hot searches run in ~12ms. Instead of dumping megabytes of raw transcripts into the context, it distills it down -- deja stats --impact shows it served 199.2 KB of distilled history on my machine instead of shoving 175.7 MB of raw logs back into the prompt. Also, after compaction, the next prompt gets a fresh digest of project memory so the agent doesn't lose the thread.

Search is lexical-first (exact error strings, function names, flags) -- a deliberate tradeoff for zero keys, zero embeddings, and instant local execution. It will miss loose paraphrases that a semantic index catches, but for exact technical artifacts, it hits fast without sending data anywhere. Known secrets (bearer tokens, private keys, high-entropy strings) are stripped during indexing (e.g., replaced with [redacted:bearer-token]).

Setup

You can set it up manually:

curl -fsSL https://raw.githubusercontent.com/vshulcz/deja-vu/main/install.sh | sh
deja install --auto

Or just paste this into your opencode agent:

Install deja memory for my opencode: run curl -fsSL https://raw.githubusercontent.com/vshulcz/deja-vu/main/install.sh | sh, then deja install --auto, then deja doctor. Tell me when it's ready.

Repo: https://github.com/vshulcz/deja-vu (MIT)

How are you handling cross-session memory right now -- MEMORY.md? rules in AGENTS.md? or just re-explaining things?

GLM-5.2 is particularly well suited to long-running engineering work: project-scale context, strong tool use and a full 1M-token context window.

The problem is that hosted models can still interrupt legitimate work when a repository or request touches security research, reverse engineering, moderation systems, mature-content products or another sensitive domain.

Wallachia Labs is preparing Dionysus, a hosted GLM-5.2 variant with a "narrower" refusal boundary and less unsolicited policy commentary. The objective is to preserve the base model’s coding and agentic capabilities while reducing refusals.

The endpoint will be OpenAI-compatible, served on Blackwell B200 GPUs, and support prompt caching across the full context window. Pricing will match GLM-5.2 on Z.ai. ( and a small bonus from us :x )

A Kimi K3-based version is planned next.

The private-beta waitlist is open:

wallachialabs.com

Insanely fast as well :P .

I wanted to look into using something like https://github.com/decolua/9router combine different ai subscriptions, so that I can leverage the best model for the task while optimising for tokens.

My current idea is to combine my Claude Max 5x subscription with an OpenAi subscription or moonshot subscription so that Fable can be the brains but use more efficient subagents (such as Kimi K3 or GPT5.6) for the workhorse tasks.

From my research I found: “routing your Claude Max OAuth through a third-party proxy. 9router logs into Claude Code via OAuth and reuses those credentials to serve other tools. This can conflict with Anthropic’s terms for subscription use and carries some account-action risk. The README even flags that certain providers (Gemini CLI) can trigger bans this way.”

What are the chances that my Claude account gets banned? Has anyone run their Claude subscription through 9router?

I’m also keen to get a conversation started for what people have done to squeeze as much as possible of of their subscriptions, let me know ⬇️

Hi i'm switching from claude to opencode,,I dont understand why for every prompt the result is looping again and again until i press esc.

Anyone pls help?
Thanks

Hi everyone,

Someone recommended me I give opencode a spin to add to my cv

So far haven't used any agents so i thought it would be fun.

I have a panther lake laptop running cachyos with 32gbram

I used to run ollama but it's honestly a bit annoying and a couple months ago it stopped using the gpu (despite previously working) and no matter what env variables it just loads to the cpu

I switched to lm Studio and it's honestly great so i tried to plug it in to opencode with qwen coder (I've tried 30b q4, 14b q8 and 4) and first it was just making my laptop crash and close every program.

After tweaking and switching to the smaller model not it worked without making my device explode but now it runs out of context no matter what i do:

I tweaked context to max and made it small,

I changed batch sized, gpu offload

The worst part is i changed max parallel options to 1 but according to the logs it keeps open code overrides this and keeps opening multiple

Is there any solution to this?

I just wanted this to toy around a but but after 6 hours of troubleshooting I'm thinking of giving up

Any other backend i could use? Maybe just use llama.cpp directly?

I use omp with opencode-go sub these days, but got some slack on the sub usage and decided to try out an expensive model (grok-4.5 - usually work with deepseek pro/flash) and for some reason omp doesn't have the grok effort levels and pi doesn't work at all for me with it so I started up the good old opencode-cli and boy oh boy does it feel like driving a 2006 car vs 2026 one. Lets take something like a simple `/goal` command - both pi and omp support this, how can opencode come without something like this bundled in 2026? The subscription is golden - there's nothing like it on the market, but the harness? Damn. Why are you still using opencode-cli?

Is anyone else worried about if Trump bans the open source Chinese models? What’s our game plan then

I would like to have several agents working on several different projects, and I would love to make it use loop engineering concepts, so it never stops unless there is nothing to do.

I tried using skills and some plugins, but eventually opencode just gives up and stop. I currently use openchamber as the web ui, but still not able to do it properly.

I did a scheduler which basically do "continue" in a project, but that is such a ugly workaround.

It is also foldable so it doesnt take much space (like mcp or todo list)

Was searching for a plugin that would show the usage status on sidebar but didn't find anything so I guess this may be handy for someone? if got any suggestion would be happy to hear!
https://www.npmjs.com/package/opencode-usage-left
https://github.com/gilvex/opencode-usage-left

Free is 256k token context
Paid is a milly token context

Twitter thread:

https://x.com/opencode/status/2079631772770242808?s=46

---

Update:

I had it recreate a mock Linux Mint on the browser. Atrocious output and I had to step in to have it copy over the dist folder to the correct directory. Additional steering needed for it to get things right.

Output: https://mint.laguna-s-2-1.demos.sulat.com/
Prompt: https://mint.laguna-s-2-1.demos.sulat.com/PROMPT.md
Skill: https://www.skills.sh/jpcaparas/skills/oneshot-websites
Variant: 1m context thru OpenRouter
Harness: OpenCode 1.18.4

Hey there guys. In terms of usage, which subscription is better? Ollama cloud pro or qwen standard?

Hello! First of all, I'm not sure if this is the right subreddit for this, but what's the cheapest way to get into AI? I want to start learning programming with AI, but I also want an AI that can control and perform tasks on my system.

I have concerns about privacy and security. Which is the best service to pay for, or is it better to use a local AI? (I don't want to use a local model because of the performance impact(i have a 5600X, a 9070 XT, and 32 GB DDR4 RAM. I know it's a good PC, but if I run a heavy model, it might use up all my resources).

edit:grammar correction.
deit 2: i use arch linux btw

I just posted a more verbose version of this at r/vibecoding, which you can read here. But if you want to cut to the chase, below is the gist of it.

Overview

Run OpenCode locally on your Android phone without root. This setup lets you:

• Run AI coding agents with OpenCode
• Build JavaScript/React/Next.js, Node.js, and Python projects
• Use Git
• Run local development servers
• Preview your web apps directly in your phone's browser using localhost
• Avoid paying for a cloud VM or carrying your laptop everywhere

1. Install Termux

Install Termux from F-Droid.

Do NOT use the Play Store version, as it is deprecated and has broken repositories.

2. Initial Setup

Grant storage access:

termux-setup-storage

Select a reliable package mirror:

termux-change-repo

Recommended:

• Main Repository
• Mirrors by Grimler (or Albatross)

Update packages:

pkg update -y && pkg upgrade -y

3. Install Development Tools

pkg install -y \
git \
nodejs \
python \
curl \
binutils \
which

4. Install GLIBC Compatibility Layer

Android uses Bionic, while OpenCode expects glibc.

Install the compatibility layer:

pkg install -y glibc-repo patchelf

pkg update -y

pkg install -y glibc-runner

5. Install OpenCode

curl -fsSL https://opencode.ai | bash

6. Patch the Binary

Tell OpenCode where to find the glibc interpreter.

patchelf --set-interpreter \
$PREFIX/glibc/lib/ld-linux-aarch64.so.1 \
~/.opencode/bin/opencode

7. Create an Alias

Add this to your shell configuration:

echo "alias opencode='unset LD_PRELOAD && grun ~/.opencode/bin/opencode'" >> ~/.bashrc

Reload the shell:

source ~/.bashrc

Now you can simply run:

opencode

8. Create a New Project

mkdir my-project
cd my-project

opencode

Inside OpenCode:

• /init
• /connect

9. Install Dependencies

Some projects require esbuild.

pkg install esbuild

Install packages:

npm install --esbuild-binary=$(which esbuild)

10. Start the Development Server

If

npm run dev

fails because Vite isn't found, use:

./node_modules/.bin/vite

11. Preview Your App

Open Chrome (or any browser) on the same phone and visit:

http://localhost:<PORT>

Your application should load normally.

Optional: Improve the Font

Some OnePlus devices stretch monospace fonts.

Install JetBrains Mono:

mkdir -p ~/.termux

curl -L \
https://github.com/JetBrains/JetBrainsMono/raw/master/fonts/ttf/JetBrainsMono-Regular.ttf \
-o ~/.termux/font.ttf

termux-reload-settings

Optional: Use an File

Download my AGENTS.md that tells the AI agents:

• They're running inside Termux & the environment is Android
• Which commands to avoid
• Android-specific workarounds

This helps reduce unnecessary retries and token usage while making agents more reliable.

Typical Workflow

1. Open Termux
2. Navigate to your project
3. Launch OpenCodeopencode
4. Ask the AI to build features
5. Run the dev server./node_modules/.bin/vite
6. Open Chromehttp://localhost:<PORT>
7. Test your application

Repeat until done.

Advantages

• No root required
• No cloud VM costs
• Fully local development
• AI-assisted coding anywhere
• Git support
• Node.js + Python support
• React/Vite development
• Local web preview
• Portable development environment

I have some API credits on Deepseek, but I'm looking for a good model for orchestration or planning; I can spend $20-25.