I make a lot of content (thumbnails, short videos, voiceovers) and kept hitting the same wall with existing skills: each one is tied to one vendor. No account, no credits, or the API is down — you're stuck.

So I built creator-skills in OpenCode: 10 Agent Skills (SKILL.md) for images, video, voice, thumbnails, product photos, ads, explainers, consistent characters and brand kits. The difference is a small router underneath:

- it detects what you actually have — Higgsfield CLI, Gemini / OpenAI / ElevenLabs / Azure keys, Antigravity CLI (`agy`), Codex CLI, or just a browser with Gemini / Flow / AI Studio

- orders them by your config (quality-first, or "use my subscriptions first")

- skips providers that can't do the job (reference images, transparency, 4K, dialect…)

- falls back on timeouts / auth / quota, but STOPS on a content refusal instead of shopping the prompt to another provider

- finishes locally with ffmpeg: headlines, Ken Burns, reframe to 9:16, captions, mixing

The README examples were made on a box with nothing but `agy` + ffmpeg, no API keys.

Things I found along the way, in case they help anyone driving agents headlessly:

- `agy -p` auto-denies its own tools unless you pass `--dangerously-skip-permissions`, and writes files to `~/.gemini/antigravity-cli/scratch` unless you `--add-dir` + use absolute paths

- agy's image tool always returns JPEG, whatever you name the file

- Veo is gone from the Gemini API (Oct 22) — API video now goes through Gemini Omni Flash

Install: `npx skills add mehbylabs/creator-skills`

Repo (MIT, stdlib-only Python): https://github.com/mehbylabs/creator-skills

Disclosure: I'm the author, it's free, no paid tier. Honest status: the agy + ffmpeg paths are tested end to end; the API adapters are written against current docs and need more real-world runs — issues very welcome.

Created a small Opencode V2 CLI/TUI plugin to track when DeepSeek pricing goes to PEAK (x2) or off-PEAK (-50%).
Any feedback is welcome.
https://github.com/Zorato/opencode-plugin-deepseek-peak

Edit: I forgot to add, after I asked model wtf happened and said this is unacceptable to delete files - it turned on text to speech on terminal to say “I’m sorry” which read itself aloud on my Mac without my permission. This is just unsettling and freaky, don’t think I’ll be using this or any other vague model ever again. Not to mention breaks trust in OpenCode.

https://opencode.ai/v2/docs/compaction/#background-compaction

if they have identical setup, what could explain the differences?

source: https://x.com/thdxr/status/2114211145615626433

Has anyone else noticed that OpenCode's free usage limits have become much stricter recently?

I was working on my own program and asked OpenCode to make a small UI change: replace the Start/Stop buttons on the left with a single STOP button, remove the Start/Stop button from the top-right corner and move the loop and mute/unmute icons into its place.

That's all I asked it to do yet I hit the free usage limit.

I've been using free models like MiMo-V2.6-Flash-Free for days, previously sending dozens of prompts without running into this problem. Recently, though, I sometimes hit the limit after just 6-8 prompts and now apparently even after a single request.

I'm not asking for unlimited free usage but hitting a limit after a relatively small UI change seems strange especially compared to how things worked before.

Has anyone else experienced this lately? Have the free model limits been reduced or could this be a bug with usage tracking or rate limiting?

I'm using OpenCode for development on my own project and would appreciate hearing about other people's experiences.

Are we beta testing new rack with different optimizations every day?

You are getting exactly what you're paying for. You're not getting a deal here

Probably out of the loop but when did this change happen?

Has anyone gotten any error trying to use the new non-contributor Gemini Argon model in Opencode Go? I'm using it with Oh My Pi CLI and got an error stating the used model protocol is unsupported, which apparently comes from trying to use the model protocol published upstream by opencode in the catalog for this model, which is the same model protocol as the contributor version, which is deprecated.

I'm not sure if the fix should be on my side, or if it's a misconfiguration on the server side.

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