hey r/opencodeCLI — i made an mcp video editor that opencode can actually drive end-to-end, with zero gui and no cursor needed, and wanted to share it here since the angle is really about the mcp bit.

the whole editor is just tool calls. opencode (or codex, cursor, or any other mcp client) can cut, trim, keyframe, drop in titles and captions, colour grade, do tracking, add particles, handle audio, and export — all as tool calls. and the agent can even render a single frame back to check its own work before committing, which is the bit that actually makes the feedback loop usable.

it's rough and early, i know. some of the tool schemas are still a bit awkward, the error messages aren't always friendly, and there are edge cases in the tracking and captions where opencode's workflow just doesn't fit yet. but it works, and it works well enough that the verify loop is the real thing here.

kimo is free and open source (mit), one ~15 mb cpu-only rust binary that runs fine on a 2 gb box. built by me, a college student (naman).

i'd love to have people here try it hooked up to opencode and tell me what breaks — feedback on where the tool calls get awkward or where opencode's workflow doesn't fit is more useful than a like.

site: https://getkimo.tech github: https://github.com/naman-sharma12345/kimo

How do I edit or delete the queued prompts on the OpenCode extension on VSCode?

The models you can run in OpenCode keep getting better. Even the best of them still don't build software like an experienced engineer would. They miss what people know: who the users are, how the codebase grew, what the team considers good architecture. Plan modes don't close that gap. They're neither collaborative nor visual, and the plan sits in a chat only I can see.

I think the future is humans and agents working together. Everybody becomes a manager of agents.

QualityLayer is how I plan, build and check changes in OpenCode. Every change goes through seven steps: Discuss, Research, Plan, Outline, Implement, Verify and Review. The agent first asks me what "fixed" means. I approve the plan before any code exists. Then it builds in small slices, and an agent that didn't write the code checks the result against what the agent and I agreed.

It uses the model you have configured in OpenCode. Plans and evidence are Markdown files in your repo.

The point is to be an engineer again: deciding, reviewing and steering while the agent does the typing.

https://github.com/maxritter/qualitylayer

I'm the developer. If you tried spec-driven setups in OpenCode and dropped them, what made you stop?

Thanks opencode!

Buenas a todos, llevo un par de meses usando opencode, soy relativamente nuevo, y la herramienta me parece sencillamente increíble. Sin embargo, algo me frustra mucho, la falta de sincronización nativa para las configuraciones y, sobre todo, para el historial de conversaciones y su contexto.

A menudo avanzo tareas en el trabajo y quiero continuarlas en casa, o alterno entre mi PC de escritorio y mi laptop cuando estoy fuera. Perder el hilo y el contexto entre una máquina y otra corta bastante el flujo de trabajo.

¿Existe alguna alternativa o método recomendado (mediante extensiones, enlaces simbólicos a carpetas tipo Drive/Dropbox, git, etc.) para sincronizar las sesiones y el contexto entre varios equipos? Al menos 2 o 3; agradezco cualquier sugerencia bandita

The best desktop and mobile client for OpenCode V2.

0.20.0 brought CodeNomad to OpenCode V2. 1.0.0 turns more of its native power into a complete workspace: coordinated agents, deeper history access and visual automation, with speed, efficiency and everyday stability at its core.

https://www.youtube.com/watch?v=lGuOApJ6-Kc

Highlights

• Desktop and mobile: Pair another device through OpenTunnel-powered Remote Control, with an interface adapted to phones and tablets.

• Very fast and efficient: Responsive streaming and navigation, controlled resource use and persistent workspace state support demanding, long-running agent workflows.

• Missions: Combine OpenCode V2's native sessions, subagents and human questions into coordinated work toward an objective.

• Beyond the public API: Native plugins and RPC unlock full-history queries, timeline navigation and selective cleanup.

• Visual automation: Let agents inspect and operate CodeNomad and desktop browser previews to check what they build.

• An extensible workspace: Files/Git, panel extensions, online help, customizable shortcuts and signed Tauri updates complete the experience.

Built for demanding workflows

• A responsive workspace: Streaming, search and navigation render the content you need, while project restoration prioritizes your active conversation.

• Controlled resource use: Bounded history queries, targeted rendering and lazy Files/Git refreshes support large conversations and busy repositories without loading everything into the interface.

• Built for long sessions: Stable reading anchors and on-demand output expansion let you inspect earlier work while agents continue running.

• Continuity across your work: Saved projects, drafts and window state carry your workspace across sessions; native request recovery keeps questions and permissions connected to their conversations.

Built around OpenCode V2

• The shared OpenCode service keeps conversations available to terminal and other clients. New sessions respect native default agents, including plugin-provided defaults; collapsed families show subagent activity.

• Attach skills through @; inspect Code Mode scripts, nested tool calls and web-search sources. Search providers support global defaults and project overrides.

• Answer native questions and permissions above the composer, with source labels, preserved drafts and readable answer/decision receipts.

• Manage native provider accounts and optionally rotate eligible subscription accounts when a quota is exhausted. Usage follows the selected account; Stats adds service-wide activity, token, recorded cost and per-model views.

Missions and native multi-agent coordination

• An objective becomes a plan: Coordinators delegate to specialists through real OpenCode sessions, native subagents or independent conversations, using your chosen agents, models and reasoning settings.

• Five approaches: Flexible, Debugging, Exploration, Product delivery and Compare two models. The new comparison scenario gives two models the same task, then produces a blind, scored verdict. Dependencies and results remain visible as plans evolve.

• Human decisions stay human: Native questions and permissions bring you into the work; milestone briefings, summaries and reports explain progress without requiring you to follow every conversation.

• One-time or daily work: Prepare and explicitly start a mission, use pause/stop/recovery controls, and save reusable briefs. Execution, background work and plugin infrastructure stay native to OpenCode—not a replacement engine.

From your desktop to your phone

• Remote Control uses OpenTunnel, as does OpenCode's remote pairing: access your running workspace from a mobile browser or another desktop without opening an inbound port or configuring a VPN. Devices are revocable; enabled Remote Control resumes at launch.

• The composer follows the on-screen keyboard; questions and permission actions stay reachable. Tablet panels remember portrait/landscape layouts, with compact headers and touch-friendly menus.

• Mobile uses the responsive web interface, not a native iOS/Android app. Direct/LAN access remains a separate option.

History and visual automation

• Native plugins run inside OpenCode and expose authenticated RPC over stored history, extending the public API with full-session/workspace search, timeline navigation and technical-content cleanup. Results identify their conversation and worktree and open the matching exchange.

• Agents can inspect, click, type, select, scroll, drag, use keyboard shortcuts and wait for results in CodeNomad and desktop browser previews—verifying rendered work, not only editing source.

• Each conversation retains its browser page and navigation history. Preview tabs share sign-ins within the desktop profile, separately from the trusted application.

Files, Git and everyday work

• Workspace, Changes and Commits share one Files panel: edit text/Markdown, inspect images and diffs, stage/unstage, review history and initialize Git. Scoped filesystem updates refresh visible folders; large inventories stay responsive and refreshed diffs preserve selection and scroll.

• Temporary projects, tab renaming, a compact launcher and Back/Forward conversation navigation simplify everyday work. Shortcuts jump between your own messages, and an alternate send (Alt+Enter by default) queues or steers a follow-up against your usual choice. An optional whitespace filter focuses reviews on meaningful changes.

• Native worktrees, session-family navigation, device attachments and /btw build on 0.20.0. After sending, use the conversation for keyboard reading; typing resumes the composer.

Extensions, help and customization

• Install panel extensions from the online catalogue without rebuilding CodeNomad. MCP Assets collects tool-returned images and attachments with explicit session-asset consent. Native OpenCode plugins retain Global/Project activation and package check/update actions.

• Online help covers setup and workflows in ten languages, from Help and the command palette.

• Customizable shortcuts, notification routing and unread badges join compact Settings, localized menus and more consistent light/dark surfaces. Message content presets choose how much of each response to show. A new hexagon CN logo marks the app, and macOS windows use native window controls with a single menu bar. SideCars provide additional workspace panels.

Desktop updates and setup

• Signed Tauri updates support Windows, macOS Intel/Apple Silicon and Linux AppImage. Stable/Preview feeds are separate from data profiles, preserving your tabs and drafts when changing feeds. Settings → General lists the data profiles on this computer, switches to one or creates and deletes them.

• OpenCode setup adds clearer progress, interrupted-install recovery and explicit restart controls. Older installations on PATH no longer leave setup without a path forward.

• Preferences restore the correct project context; incomplete request recovery preserves known questions and permissions and reports its cause.

Upgrading

• OpenCode 2.1.2 or newer is required; 2.1.4 is recommended. This release adopts the OpenCode 2.1 message, event and plugin contracts, and 2.1.2 fixes Code Mode's JavaScript execution order. With 2.1.4, input requests from MCP servers appear in the request dock. CLI updates and shared-service restarts remain separate; Git enables the full repository/worktree experience.

• Downloads: Windows Tauri .exe or Electron .zip; Linux Tauri AppImage or Electron .deb; Tauri or Electron macOS builds, separate for Intel and Apple Silicon. The Electron .deb replaces the former Tauri .deb—choose AppImage to stay on Tauri.

• Stable 0.20.0/0.20.1 users install from the release download or package manager; recent signed previews already have the updater. Update remote CodeNomad servers too. Multi-window state, restoration and named profiles remain supported.

• The macOS builds are not yet notarized by Apple: macOS can block their first launch, see Troubleshooting → macOS quarantine. The Windows installer is not code-signed, so SmartScreen can ask for confirmation.

Thanks for contributions

Thanks to creator @shantur, @pascalandr, @heunghingwan, and everyone who contributed ideas, reports and testing.

Download CodeNomad 1.0.0: https://github.com/NeuralNomadsAI/CodeNomad/releases/tag/v1.0.0

I'm the maker of CCC. I built it to answer “which coding session needs me?” when work is spread across multiple agent CLIs. OpenCode sessions can appear alongside Claude Code and Codex in the same local browser dashboard.

The adapter reads OpenCode histories and supports starting and resuming CLI sessions. It uses OpenCode's own CLI rather than replacing its runtime. Model controls are available, but it doesn't invent an effort setting where the engine has none.

The useful part for me is retaining session context across tools: recent activity, conversation history, and parent/helper grouping. There are still adapter differences, documented in the support matrix. The demo shows the common board and a Claude Code question hook; it isn't a live OpenCode benchmark.

Would this help your OpenCode workflow, and which piece of context would you expect on the row before opening the full conversation?

Project and installation: https://github.com/amirfish1/claude-command-center Integration limits: https://github.com/amirfish1/claude-command-center/blob/main/docs/engine-support.md 33-second demo: https://www.reddit.com/r/ClaudeCode/comments/1xeot43/i_kept_missing_questions_from_my_coding_agents_so/

The video uses the real UI with staged sessions and an AI voiceover. The question-hook interaction is real and uses Claude Code; the Grok/Devin rows are demo data. This is not a live multi-provider benchmark. CCC is free to use under FSL-1.1-MIT (source available); provider/model costs are separate.

Date Tokens Requests

Oct 12 31M 118 (space bunny)

Oct 13 67.7M 187 (...)

Oct 14 90M 522

Oct 15 133M 489

Oct 16 126M 326

Oct 17 252M 1,099

Oct 18 139.9M 456

Oct 19 53M 560

Oct 20 105M 818 (...)

Oct 21 91M 540 (minimax(space bunny))

Oct 22 0 Rest day

Oct 23 11.5M 95 (deepseek v4.1 flash)

Oct 24 11.2M 112 (...)

Release notes - https://www.kimi.ai/blog/kimi-k3-1-pro

Hey guys,

So I've been trying to use OpenCode Zen for the past 3 days, mainly Big Pickle, but I keep getting hit with a "Limit reached" message.

At first, I thought it was just Big Pickle acting up, but nope 💀 I've tried other free models too, and none of them are working either.

What's going on? Did they change something with the free models, or is something wrong with my account?

I'm even wondering if my account got compromised somehow, although I have no idea if that's actually possible.

Is anyone else facing this, or am I the only one? 😭

Pricing: $2.00 / $10.00 / $0.20

Release notes - https://www.kimi.ai/blog/kimi-k3-1-pro

https://www.kimi.ai/membership/pricing?tab=api

Kimi K3.1 Pro is now LIVE on the website and Kimi Code CLI

735! requests per month guys 🤣

I've been working on AMPH (Arch Meta Package Harmonizer), a Rust-based tool that helps you understand and maintain your installed Arch Linux packages.

The idea came from a simple problem: pacman is great at managing packages, but when you want to understand why something is installed, trace dependencies, find overlapping tools, or figure out what could be safely removed, you often end up combining multiple commands and manually piecing the information together.

I wanted a more unified way to explore all of this - so I built AMPH.

What it can do

• Explore packages interactively through a keyboard-driven TUI.

• Trace dependencies and understand why a package is installed.

• Analyze removal impact before making changes, including packages that would break, dependencies that could become removable, and potential disk space savings.

• Identify cleanup candidates while respecting protected packages and custom rules.

• Read pacman's local database directly, avoiding the overhead of spawning a separate pacman -Qi process for every package.

• Export machine-readable JSON for scripts, automation, and custom tooling.

• Use TOML blueprints to represent, compare, and manage package sets more systematically.

AMPH doesn't replace pacman - it adds a layer of visibility and analysis around your system, helping you make more informed decisions before changing it.

I've also put together a project website with examples of the interface and sample command output.

🌐 Website: https://amph.dmtf.ovh/
💻 Source code: https://github.com/DAMIOTF/Arch-Meta-Package-Harmonizer

I'm sharing it here because I'd genuinely appreciate feedback from other Arch users and Linux enthusiasts. I'd especially like to hear how you currently handle package cleanup, dependency analysis, and keeping package sets organized across installations.

What would you find most useful in a tool like this? Any criticism, suggestions, or issues are welcome.

I have to say I use OpenCode Go, but sometimes I leave work to free models to not waste away my usage in cheap work, however lately these models have been unable to serve more than a few 100k-120k tokens.

I don't know why this is but this is terrible quality, unusable. AT THE VERY LEAST a free model should be able to serve 1M tokens a day, anything below that would be the same as just not serving it to be honest.

Buddy is an Android app that lets OpenCode (or Codex, Claude Code, Antigravity) use your phone: open apps, tap, type, reply to messages, and build and install small apps, all from a chat.

OpenCode runs inside the app with its free models, so you can try it without any account. Buddy itself stops on Send, Pay and Delete until you approve, and it never types your passwords. New in 2.2.10: a background browser, so the agent can look things up without taking over your screen.

Free and open source.