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

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 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?

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 ⬇️

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?

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.

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

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!!!

Or are most of you only using it with set skills

Do you know why it's not implemented yet?

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?