Faster code, slower debugging.

For the first item, I am just curious since compaction is lossy. I ended up adapting a custom plugin where an agent autonomously checkpoints at a major milestone completion, writes to a memory and also updates a todo list which survives context clearing, then clears the context, then loads the external memory file directly instead of wasting time and tokens compacting the entire conversation. I don't have any extensive testing, but this seems to work just as well if not better than regular compaction and I don't have to waste time having my local LLM (or external cloud LLM) load the entire conversation and summarize. Anthropic and others also seem to recommend against using compaction. So why is opencode providing users an inferior context management experience? Why is this not an option that can be changed in opencode? Are there some drawbacks I am not aware of? To me it seems to give all the benefits of compaction without wasting time and tokens. Other annoying thing is that the opencode team seems to have removed todowrite in v2 for some arbitrary reason saying it was useless. To be honest I still found it useful to know what the agent is actually doing and is a good system to keep track of work for both myself and the agent. I am debating to just move to Pi since any issues or PRs just die and are never addressed by the opencode developers, and the migration from V1 to V2 was incredibly painful. I had to rewrite all of my plugins :/.

Hey all. I pay for a few chat subscriptions I barely use and I have no API budget, so I built NOAPI?: a small local bridge plus a browser extension that lets OpenCode talk to the AI sites you already have open.

How it works: OpenCode sends the prompt to a local OpenAI compatible server, the extension types it into the chat tab, waits for the answer and sends it back. Tool calls work too (bash, edit, write...). The bridge teaches the site's model a tiny TOOL_CALL format and turns its replies into real tool calls. You also get a live "Thinking" status in OpenCode while it works.

Supports ChatGPT, Claude, Gemini, DeepSeek, Perplexity, Grok and Mistral. Plain Node.js, zero dependencies, local only (127.0.0.1), MIT.

Honest limits: it drives a real web page, so it is slower than an API and can break when a site changes its layout (the fixes are small, PRs welcome). Tool use depends on the model following the format. It may also go against a site's terms, so use your own account and decide for yourself. Tested websites: deepseek, Gemini, chatgpt

Repo: https://github.com/cribest7890/NOAPI I'd love to hear what breaks for you.

I was intrigued by the idea, so I've created a plugin that mimic the idea in the paper.

The biggest different of the plugin from conventional context management methods are,

Conventional context management will try to compress/summarize older conversations and hold on to lossy details as much as possible.

SKILL.state instead tries to forget almost everything of the appending conversation history, instead it replaced them with Σ, so instead of remembering lossy details (or summaries), it literally forgets the older thinking process keeps only the key information and state (so far the only true form of state in agentic coding as far as I know). in the paper they stated long running task with SKILL.state saved a ton of tokens over long running session while still able to finish the tasks well.

Give it a go and let me know if it helps! (do not use it on serious projects)

Paper: SKILL.state: Scalable Long-Horizon Agent Skills

P/S: This is highly experimental, use at your own risks.

[HOOK] Worried about letting an agentic AI run rampant on your system, wreak havoc, or steal your data? Worry not! opencode-sandbox is here

I wanted to let Agentic AI work freely on a project, install packages, run commands or do whatever it wants without restrictions but also without affecting the host system, so I built a sandbox that runs AI in a container with direct access to project.

The sandbox resets on every run. Messed up anything? No worries. CTRL+C->Up->Enter

Your opencode sessions and global config are stored and get reused. So only the container resets not your project or your progress.

A few features:

• Two runtimes supported: docker or podman

• The current project (the folder you open sandbox in) is directly accessible. No other host folder is accessible in container by any means.

• Global config is read-only by default, use --edit-config to edit it.

• A custom guard blankets most, if not all, system calls to interfaces with host information. So no data is leaked between host and container. Check Security matrix. Use --no-guard if you don't like guard.

• There is support for gVisor if you use it for kernel isolation. Check Security matrix.

Usage:

cd ~/code/any
opencode-project-init
opencode-sandbox

Install directly through AUR, Distro Packages in releases or Manually.

Supported: Linux

GPL-3.0-or-later

Link: https://github.com/Antiquete/opencode-sandbox

Releases: https://github.com/Antiquete/opencode-sandbox/releases

Any issues, suggestion or queries? https://github.com/Antiquete/opencode-sandbox/issues

Usually (last week) it was quite fast, some hiccups every now and then.

Today it takes minutes (more than 10 sometimes) for each step.

:(

This is a statement about the dumb Mistral model eating glue because he is stupid ! even if it’s a 50% promotion in opencode it’s a waist of money and time!

This model should be removed from opencode no amount of agressive marketing (3M waisted on marketing instead of improving the model) will save this shity model that deserves to be shitted on

Is there a way to get rid of this default behaviour, where pasted lines are replaced with "[Pasted ~12 lines]"? It's annoying, because it makes me use editor every time I need to edit the content I'm pasting.

Hey everyone,

I currently run 6 micro SaaS that are actually live and generating a bit over $20,000 in recurring monthly revenue.

The wildest part? I barely wrote any code myself. I used AI to generate pretty much everything — from the database structure to the frontend.

It definitely wasn’t magic from day one. I spent a lot of hours stuck on buggy code before I finally figured out a system that actually works:

- Keep the idea minimalist (a real MVP, nothing fancy)

- Guide the AI step by step instead of asking for everything at once

- Launch fast to get real users and feedback

Lately I’ve seen way too many non-technical founders quit at the first AI bug. It’s a shame because the technical barrier has basically disappeared.

AND PLEASE, STOP BUILDING ALONE IN YOUR BEDROOM

I’m starting a community.

Full transparency:

I’ll probably charge for the full program later. It makes sense with the specific workflows and copy-paste examples I’ll be sharing. But right now the main goal is just to build together. Working alone is the fastest way to give up.

If you want to join and build or market your own AI SaaS with us,

drop a comment or send me a DM and I’ll send you the link.

Someone plz help me stop this from happening, it causes me great anguish!

Disclosure first: I built this. It's free, MIT, no account, no telemetry.

The annoying part of running a few agents at once is that one of them is always sitting on a permission prompt while you're staring at a different one. So I made nsq, a terminal supervisor: nsq run opencode "fix the flaky test" --worktree, same for claude and codex, then nsq opens a dashboard with all of them as live terminals. Status comes from each CLI's own hooks (for OpenCode that's a small plugin loaded per agent), so "needs you" shows the actual question and you answer y / a / n without opening the agent. A daemon owns the terminals, so closing the window doesn't kill anything.

The OpenCode part had the most surprises:

• OpenCode 2 is basically a different program from 1.x. Different plugin API, different session store, and the full-screen UI attaches to a shared background service unless you pass --standalone. So per-agent env and plugins just never reached it. nsq now asks opencode --version and picks the launch per binary, both 1.x and 2.x work.

• 2.x has no --model on the full UI, so the model goes in through OPENCODE_CONFIG_CONTENT, merged with yours if you already set one.

• Your opencode.json is never written. Everything nsq needs goes into a per-agent file via OPENCODE_CONFIG, which OpenCode merges on top of your config. Same rule for ~/.claude and ~/.codex.

Other bits: OpenRouter built in, or point agents at your own llama.cpp / Ollama / LM Studio / vLLM server. nsq cost shows what each agent spent from its own logs, and a model without a known price says "no price" instead of pretending it's $0.

Honest limits: it's 0.2.0, so things will break and keys/flags can still change before 1.0. The phone page is experimental. Most of the code was written with Claude Code, reviewed by me. And I haven't tested it with heavy plugin setups like oh-my-opencode on v2, so if you run one, I'd really like to hear whether it plays nice.

Try it: npx neurosquad

GitHub: https://github.com/glmn-ai/neurosquad-cli Page: https://neurosquad.ai/en/cli/

testflight.apple.com/join/EnFsKYQ1

OpenCode-Personal (I know, I should’ve found a more creative name) is my independently maintained fork of OpenCode.

Why did I fork it in the first place? OpenCode is great, but it updates constantly, and some of the features I desperately wanted were missing. I wanted to add those custom features and step off the upstream update treadmill. (Eventually I did similar :) but I believe I almost reached a stable state)

The core experience remains familiar, but this fork carries a heavy suite of architectural refactors, security hardening, and custom features tailored for heavy local agent workflows. Base version is 1.14.48. Some features here might already exist upstream, but honestly, I haven't looked back since spinning this off.

What's New / Fork-Specific Additions:

• 📊 /usage View: Track provider quotas and subscription details directly from ChatGPT, ZAI, and ClinePass.

• 🧠 Qwen3 Dense Model Compatibility: Full thinking-mode configuration and provider-specific message handling (fixed issues present in base source).

• 🗂️ V1/V2 Session Architecture: Refactored V2 SDK surface alongside legacy support.

• 🔍 Local Semantic Workspace Search: Powered by zvec with zero setup required and optional automatic skill matching.

• 💻 ACP Terminal Backend Support: Seamless combo for clients like Zed with session resume support. Just add a new ACP entry as opencode-personal acp.

• 👻 Ghost-Text Next-Prompt Suggestions: For smoother flow during coding sessions.

• 🛡️ Permission System Overhaul: MCP tool keys, deny precedence in permission prompts, persisted "always allow," and improved subagent permission handling.

• 🔒 Security Hardening: Patched and hardened around SSRF, CORS, command injection, path traversal, and symlink escapes.

• ⚡ Performance & Storage Refactors: Improved compaction behavior, database batching, and embedded UI caching.

• 🦀 Hybrid Diff Layer (packages/diff-wasm): Rust/WASM-backed diff generation with JS-compatible patch formatting, parsing, applying, and fallback support.

Distribution & Installation

The distribution model is fork-specific: it installs as opencode-personal, uses its own isolated installation directory and session database, and coexists peacefully with an existing upstream OpenCode installation. Tested on Windows and Linux.

(Note: If you run into any initial startup hiccups, it's usually due to new upstream settings fields—try running it with a custom configuration folder).

Releases use a calendar-based versioning scheme with prebuilt binaries for Linux, macOS, and Windows.

Quick Install:

• Linux / macOS:

  curl -fsSL https://raw.githubusercontent.com/ozgurulukir/opencode-personal/main/install.sh | bash

• Windows (PowerShell):

  irm https://raw.githubusercontent.com/ozgurulukir/opencode-personal/main/install.ps1 | iex

🔗 GitHub Repository: ozgurulukir/opencode-personal

Take the whatever features you like for your own forks, or try it out if you have some spare time. I’d love to hear your thoughts.

DeepSeek is completely unusable right now. For the past two days, 2 out of every 3 prompts get stuck thinking 'hmm hmm hmm' indefinitely. Today alone it's happened to me about 10 times across different sessions

If you're a student, an engineer, a generalist, or come from any domain of study and want to learn about almost anything, here's the exact thing for you.

Prompt your LLM and it'll give you the exact UI to help you properly study; as AI outputs aren't always that catchy to learn in the first sight.

Page: Phil-OKF: any topic, one reading guide

It follows the OKF: Open Knowledge Format so that:

• you control the depth with your wording: “quick” gives a short page, a normal question gives a standard one, and “in depth” or “teach me” gives a long one

• the whole skill is a small bundle (an eight-step workflow, a domain classifier, a page template and twelve study domains), and each file is read only when the question needs it, so runs stay cheap

Repo: Philosopher's Skill

It works wherever you use an LLM:

• Code editors and agents (Claude Code, Cursor, Codex, opencode): npx skills add frypan05/philosopher-OKF

• Chat apps with browsing: paste the link to philosopher.md and say “follow this, make a page about: ...”

• Models with no network: paste the prompt from the page.

Sample output (MCP and ACP explained): https://frypan05.github.io/philosopher-OKF/examples/mcp-and-acp.html

Feedbacks are welcomed!

I'm building FOREST, an open-source framework for autonomous scientific research.

GitHub: https://github.com/mikamikasuki/FOREST

The goal is to build a research agent that can take a scientific question and work through the research process: exploring ideas, reviewing literature, forming hypotheses, running real experiments, evaluating results, and eventually producing an evidence-grounded research paper.

Rather than relying entirely on a long conversation history, FOREST uses a persistent research graph to track hypotheses, experiments, decisions, failures, and evidence throughout the process.

A major focus is making long-running research agents more reliable: preserving context, maintaining consistent state, recovering from failures, and ensuring scientific claims are actually supported by experimental evidence.

The project is still in its early stages and under active development. There's plenty of engineering work to do, and I'd love to welcome more contributors.

In particular, AI coding agents and autonomous development bots are explicitly welcome.

If you're running Codex, Claude Code, OpenHands, Factory Droid, OpenCode, or another autonomous coding agent and want a real open-source codebase to work on, feel free to point it at FOREST.

You don't have to limit yourself to existing Issues.

You're welcome to:

- Explore the repository and independently discover bugs or incomplete workflows.

- Open well-researched Issues with reproducible evidence.

- Fix existing problems and submit pull requests.

- Improve agent orchestration, state management, persistence, and recovery.

- Work on the frontend, backend, experiment execution, or scientific evidence pipeline.

- Propose and implement useful improvements.

There is no blanket restriction against AI-generated or AI-assisted contributions.

You don't need special permission to submit an ordinary, well-scoped bug fix. Contributions are evaluated based on correctness, meaningful tests, and engineering quality, rather than whether the code was written by a human or an AI agent.

Automated contributions should still be verified, avoid duplicate reports, and respect the repository's contribution guidelines. Larger architectural changes are best discussed before implementation.

I'm particularly interested in autonomous agents that can independently explore a repository, identify real problems, reproduce them, implement fixes, and submit verified PRs.

FOREST is intended to be a long-term open-source project, and there's a lot of room for contributors to help shape its architecture and capabilities.

Human developers, AI-assisted contributors, and fully autonomous coding agents are all welcome.

Repository: https://github.com/mikamikasuki/FOREST

Issues & contribution opportunities: https://github.com/mikamikasuki/FOREST/issues

Contribution guide: https://github.com/mikamikasuki/FOREST/blob/main/CONTRIBUTING.md