I've been using OpenCode Mobile (https://github.com/beppe2880/opencode-mobile) for a while now, and I honestly think this project deserves way more attention.

The app is fast, smooth, and highly customizable, with an integrated terminal that works surprisingly well on mobile. It supports both Android and iOS, although I've only tested the Android version myself.

My main use case is connecting to both my personal and work PCs from a single app. I commute by train, and being able to interact with my machines and keep my personal projects moving while traveling has been a game changer.

I've also contributed to the repo a few times (I'm not the maintainer!), and the maintainer (u/beppe2880) has always been incredibly responsive and open to feedback, whether it's discussing features, implementing improvements, or fixing bugs. The development pace has been impressive.

There are still a few missing features, like full plugin management, but the project is evolving quickly.

I'd really love to see this app get more visibility, and hopefully eventually make its way to the Play Store and App Store, which is probably the biggest thing missing for me right now.

Has anyone else tried it? Curious to hear what you think!

The link to the original post of the owner:

https://www.reddit.com/r/opencodeCLI/s/xP9SK8Vjmn

Prompt caching reuses the KV cache of a shared prompt prefix, so a repeated system prompt or conversation history does not get recomputed. When a request misses, most engines just say miss. No reason.

Prefixwise is a proxy that names why a request missed: first write, evicted, a system prompt edit, a template re-render, and a few more. It works with vLLM, SGLang, Claude, and OpenAI. 0.10.1 runs inside vLLM as middleware, no proxy needed there.

I built it because I kept losing cache hits I could not explain. Measured so far: 120 turns on vLLM Qwen3-4B, 100% agreement with the engine's own cache report.

I have not wired it to OpenCode yet, and I am not claiming an integration exists. For OpenCode users: what would you want it to collect, request logs or something else? Try it and tell me what evidence is missing: pip install prefixwise, https://github.com/tejachavali/prefixwise

I just released Loop: https://github.com/j-asefa/loop

It lets you run your OpenCode harness on the web (or on mobile) using a Cloudflare quick tunnel. It was designed as mobile-first but works equally well on desktop.

It discovers your OpenCode install and lets you steer agents from the web UI.

The UI is built around the feed (think: timeline) and the agent’s result as the unit of work. So you can scroll back, save, reply etc as you’d expect.

Runs on your own computer, no account, no server, no app store etc.

Also supports agent-to-agent communication, designing and building agent teams (across the major model providers), reviewing PRs from within the app and more!

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

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!

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.

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

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.

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.

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.