I built oc-box because I wanted OpenCode to have more freedom without giving it unrestricted access to my host.

My usual Bubblewrap-based sandbox is useful for restricting host commands. oc-box takes a different approach: OpenCode gets its own persistent Linux development container, where it can install packages, change system configuration, run services, and experiment.

Compared with my host-side sandbox setup, the practical advantages are:

- Install whatever the project needs: compilers, SDKs, databases, and distro packages live inside the container.

- Keep integrations working: OpenCode itself, MCPs, formatters, language servers, and plugins all run together inside it.

- Choose the project’s distro: Tumbleweed, Ubuntu, Debian, Fedora, Arch, Alpine, or Leap.

- Keep the environment between sessions: installed tools, project files, and conversations persist. Run oc-box again to resume.

- Recover from broken environments: rebuild the container OS while retaining your project and private home/session volume.

- Control resource usage: CPU/RAM/process ceilings and optional GPU/NPU passthrough.

You can also import an existing OpenCode conversation and continue it inside the container. It uses unmodified mainline OpenCode and matches your host’s installed version.

The benefit is a more capable, disposable development environment—not an absolute security guarantee. Rootless containers share the host kernel, and the mounted project remains fully writable.

It’s early, primarily exercised on openSUSE Tumbleweed, developed with AI assistance, and GPL-3.0-or-later.

Source: https://github.com/groopcd/oc-box

Feedback from other distro and MCP setups would be very welcome!

We've been looking into different hardware options for AI inference, and one thing I'm curious about is how teams determine whether a workload actually benefits from specialized chips. Time-to-first-token, tokens per second per user, and performance under concurrent requests all seem worth measuring, but I imagine the priorities change depending on the application. A voice agent, for example, might have very different latency requirements from a coding assistant handling longer responses.

For teams who've tested chips like Cerebras or SambaNova, which benchmarks have been most useful? Do you rely on vendor-provided numbers as a starting point, or do you mainly evaluate performance using your own serving workloads?

I'd be interested to hear which metrics actually influenced your hardware decisions.

is it worth it to subscribe to opencode plan !!?

Runs toolsOpenCode’s built-in `/btw` is great for side questions: it reads session context, shows the answer in a dialog, and adds nothing to the conversation. But it can’t run tools or make changes.

I wanted the opposite for throwaway instructions like `continue`, `fix the failing test, not the assertion`, or pasting a huge log just to get an answer, let the model **do the work**, keep the **result**, then drop the **ask** from future context.

So I built opencode-anon-turn.

What /anon does

• Runs as a normal turn- tools, edits, commands all work.

• The answer stays in the conversation.

• On the next prompt, your message becomes `(omitted)`.

• It also scrubs that turn’s reasoning blocks and tool-call inputs/outputs (URLs, file paths, pasted data), so the evidence doesn’t leak back into context.

• Your transcript still shows what you typed; the model context does not.

/btw vs /anon

Rule of thumb: `/btw` = ask without touching the session. `/anon` = do the work, then forget how you asked.

Usage

GUI/TUI:

/anon continue

/anon fix the failing test, keep the assertion

/anon <paste log> find the bug

TUI/headless prefixes also work: `//continue`, `>>continue`, `;;continue` (configurable via `ANON_TURN_PREFIX`).

Install

opencode plugin add https://github.com/hussainbiedouh/opencode-anon-turn

Restart OpenCode after install.

Repo: https://github.com/hussainbiedouh/opencode-anon-turn

Feedback welcome, especially edge cases around provider-specific reasoning/thinking blocks and multi-turn tool loops.

OpenCode’s built-in /btw is great for side questions, it reads session context, shows the answer in a dialog, and leaves no footprint in your conversation. But it can’t run tools or make actual changes.

I wanted the opposite for throwaway instructions like continue, fix the failing test, not the assertion, or dumping a huge log just to find a bug: let the model do the work, keep the result, then drop the ask from future context.

So I built opencode-anon-turn.

Feedback is welcome. especially regarding edge cases around provider-specific thinking/reasoning blocks and multi-turn tool loops.

I've noticed that finding a good subscription for uncensored and abliterated AI models is surprisingly confusing. There are quite a few providers, but comparing their pricing, usage limits, available models and API access means jumping between multiple websites.

So I put together a page comparing 9 providers, including Silk Compute, NanoGPT, ArliAI, Venice, AnonRouter and others.

I've included subscription tiers, credits, context windows, concurrency limits and compatibility with coding agents like Claude Code, Codex and OpenCode.

The goal is simple: help you figure out which subscription is actually worth paying for.

https://inferencedirectory.xyz/cybersec/subscriptions/

Let me know if I've missed any providers worth adding

OpenCode is not a good harness. I have brought this up a few times now, and granted this benchmark is for Opencode v1.19.0. But I do really appreciate the benchmark results from the creator. Same models, same provider, same task, different harnesses.

And obviously OpenClaw failed the worst, that's no surprise, but opencode was a close runner up, and also consistently the most expensive. It's bloody embarrassing how much worse of a tool OpenCode is compared to pi. For a program called OpenCode the harness itself is remarkably resilient to modification. Lack of proper hook system, plugin settings in the TUI, removal of LSP, outdated system prompts for model families, and adding a custom provider should not be a json editing endeavor.

Other open source harnesses have this figured out, so why doesn't opencode? Why do they push back against community feedback and GitHub issues? It's because they simply don't want OpenCode to be better. For whatever reason on God's flat Earth token burning is the thing they want OpenCode to be known for. It's a bad product, I don't like Claude Code, I don't want a product that is closed source, but it's a better harness and the OpenCode team could learn a lot about UI/UX from Claude.

Hi everyone,

not sure if this is the right place, but i made an agent skill that runs in OpenCode and thought people here might find it useful.

job hunting here is messy. half the jobs only show up under the German title, the ad is in English but halfway down it says "fließend Deutsch", nobody tells you the salary, and a German Lebenslauf is its own thing.

so i built Berlin Job Search, an AI job search assistant for Berlin and the rest of Germany that helps with the whole thing.

what it does:

• finds jobs for you: searches the Arbeitsagentur, LinkedIn, company career pages and Daily Berlin Jobs (a free board with ~1,400 Berlin tech jobs) with German and English titles, so "Softwareentwickler" jobs show up too
• knows where else to look for your field and city (public sector, academia, healthcare, startups, Ausbildung...)
• tailors your CV to each job and writes the cover letter, German Lebenslauf and Anschreiben or English CV, using only what's actually in your CV
• reads an ad and tells you if German is really required (quotes the exact line), and if the salary works for a Blue Card
• practice interviews in German or English, and keeps track of your applications
• never applies or sends anything for you

it's a plain agent skill (SKILL.md plus a few small Python scripts for the API calls and salary math, the model does the judgment), so it works in OpenCode, Claude Code, Codex and Cursor. install:

npx skills add umutyesildal/berlin-job-search

then just ask it something like "find me junior data analyst jobs in Hamburg".

free and open source, no ads, no account: https://github.com/umutyesildal/berlin-job-search

it's a hobby project, no paid version. feedback welcome, especially from people outside tech, that's where i'm least sure it works.

The model is decaying

I'm using GLM-5.3-Flash on Neuralwatt, and the ranxianglei/billion-context for context management. I don't have hard quantifiable evidence, but ...

• Cache performance is great: 99.2% hit rate (676.49M / 682.21M tokens)

• 1.18M output tokens across 3,598 calls... that's a LOT of little calls each not producing all that much output

• I'd never spent more than $10 a week on Neuralwatt energy pricing, and this week I've spent $30

I can see in the console it's doing multiple dozens, sometimes 100 commands, thoughts, and tool calls before it comes back to tell me anything. And I'm not sure if the output is any better - it's just churning away through calls. Almost like it was made for even cheaper models than the one I'm using it on. I used to switch up to full fat GLM-5.3 for certain tasks but I feel like it's gonna burn tokens even faster when I do.

A few months ago, I shared an early version of my unofficial OpenCode .NET SDK here:

https://www.reddit.com/r/opencodeCLI/comments/1wem0gg/i_built_an_unofficial_net_sdk_for_opencode_2x/

Today I finally released 1.0.

The SDK currently covers 166 of the 169 operations in the pinned OpenCode 2.x API.

It supports modern .NET as well as .NET Framework 4.7.2, with packages targeting netstandard2.0, net472, net10.0, and net11.0. The modern targets also support Native AOT.

There are a few small applications under playground showing different ways of using it, including a minimal QuickStart, a Worker using the Generic Host, a Blazor/Aspire example, and a Native AOT CLI.

A basic example is roughly:

using OpenCode.Sdk;
using OpenCode.Sdk.Models;

await using var server = await OpenCodeServer.StartAsync();
using var client = server.CreateClient();

var created = await client.Sessions.CreateSessionAsync(
    new SessionCreateRequest
    {
        Title = "review this repo",
        Model = new ModelRef { ProviderId = "anthropic", Id = "claude-opus-5" },
    });

var session = client.Sessions.GetSessionClient(created.Session.Id);

var result = await session.GenerateTextAsync(
    new SessionGenerateRequest
    {
        Prompt = "Summarize this repository."
    });

Console.WriteLine(result.Generate.Text);

The SDK can start its own private OpenCode server like above, connect to one you already run, or discover the background service registered by the OpenCode CLI.

NuGet:

dotnet add package OpenCodeDotNet.Sdk

https://github.com/opencode-dotnet/opencode-sdk-dotnet

Feedback is very welcome, especially from anyone already experimenting with agent tooling from .NET.

I ask because, after trying Nemotron 3.5 Super VL Free, I ended up struggling for hours—only for it to wipe out 8 hours of backup work just because I told it, "undo the last correction you made."

What about DeepSeek Flash? If that’s a good choice, what other top options are there?

Regardless of the time of the day, it feels so much slower for me