If you have been searching for the hermes opencode skill, here is the short version: it is a skill you switch on inside the Hermes agent that stops Hermes writing code itself and makes it hand every build to OpenCode instead. Hermes becomes the manager. OpenCode becomes the builder. And you become the person who reviews finished work instead of babysitting a chatbot through every broken file.
This page is about the skill itself. Not the free-models story, not the wider integration architecture — just what the skill does, how delegation behaves once it is on, how to enable it in plain English, and when it is worth using. Everything here comes from Julian Goldie’s hands-on build, where he runs this exact setup inside his Agent OS.
What Is the "hermes opencode skill"?
Quick context. Hermes is a free AI agent. OpenCode is an autonomous coding CLI. Left alone, Hermes will happily write code in the chat window — and like most chat agents, it is a mediocre builder.
The skill rewrites its job description. With it enabled, Hermes uses OpenCode as an autonomous coding worker, orchestrated by Hermes. Hermes never opens the editor, so to speak. It briefs OpenCode, supervises the job, and signs off on the result.
Think of it as hiring rules for your agents: Hermes is the project manager, OpenCode is the developer, and the skill is the employment contract that keeps each one in its lane.
What Changes the Moment You Enable It
Before the skill, a coding request is a conversation. You ask, Hermes writes, you paste errors back, it apologises, you repeat until you give up or it does. After the skill, a coding request is a delegated project with an owner, a worker and a checklist.
The delegation loop, step by step
- A coding task appears. It can arrive from a chat message or from a ticket on the Kanban board inside the Agent OS — both routes trigger the same behaviour.
- Hermes hands the build to OpenCode. It does not attempt the code itself. Delegation is the default, not a favour you have to ask for.
- Hermes monitors the job. While OpenCode works, Hermes stays on watch rather than going quiet and hoping.
- Failures get retried automatically. If a build errors out, Hermes sends it back round without you touching anything.
- The artifact gets verified. Hermes checks the finished output before it ever calls the task done.
That last step is the underrated one. Most agent setups declare victory the moment code has been generated. This one declares victory when the thing actually exists and passes inspection. The practical effect is simple: you stop babysitting the coder.
📺 Watch: How To Get FREE Skills For Hermes Agent
With the Skill vs Without It
| Question | Without the skill | With the skill |
|---|---|---|
| Who writes the code? | Hermes, inline in chat | OpenCode, as a delegated worker |
| What is Hermes doing? | Typing HTML into the conversation | Orchestrating: briefing, monitoring, verifying |
| What happens when a build fails? | You paste the error back and hope | Hermes retries it automatically |
| Who checks the result? | You do, manually, every time | Hermes verifies the artifact before marking it done |
| Your role | Full-time babysitter | Reviewer of finished work |
| Token usage | Heavy — long code dumps in chat | Leaner — the orchestrator stays out of the build |
| Where can tasks come from? | Chat only, one at a time | Chat or Kanban tickets, batched |
How to Enable the Skill (No Config, No Terminal)
This is the part people overcomplicate, and the honest answer is refreshingly boring: you do not configure anything manually, and you do not run a single terminal command.
You go into Claude or Hermes and say it in plain English. Something like:
- "Use this system for coding."
- "Delegate coding tasks to OpenCode."
The agent wires the skill up for you. That is genuinely the whole setup.
You can also be explicit inside any single session. Tell Hermes directly to use OpenCode whenever it is doing coding tasks, and it will follow that instruction for the work in front of it. Either way, the barrier to entry is one sentence, not an afternoon of documentation.
Why plain English is the right interface
This matches how the whole Agent OS is meant to be driven: you describe the behaviour you want, and the agent handles its own wiring. If you are the sort of person who bounces off config files, that is precisely the point — the system was built so you never have to meet one.
📺 Watch: New Hermes Agent Skill Bundles are INSANE!
The One Rule the Skill Enforces: Hermes Never Writes the HTML
Here is the discipline at the heart of the skill, and it is Julian Goldie’s key rule: Hermes never writes the HTML. The profile is trained so that every single build goes through OpenCode. No exceptions, no "just this once".
Why be that strict? Because the separation between orchestrator and builder is what makes the whole system hold up:
- Quality stays up. The builder does focused building and the orchestrator does focused checking. Nobody is marking their own homework.
- Tokens stay down. Hermes is not burning its context on code dumps, so the manager stays cheap and sharp.
The moment your orchestrator starts freelancing as a coder, you are back to one confused agent doing two jobs badly. The skill exists to stop that drift before it starts.
What It Costs to Run
The pricing conversation is short: Hermes is free, and OpenCode runs on free APIs and models. Julian Goldie runs it on Big Pickle, with Ling 3.0, OmniRoute and North Mini Code as alternative brains. Put together, the skill effectively hands you a free autonomous coding worker.
One honest caveat: free tiers can rate-limit. When one free brain dries up mid-session, you swap to another — which is exactly why the alternatives matter. As for which free model is behaving best at any given moment, that is the sort of thing Julian Goldie puts through Goldie Bench, his own hands-on testing of the models he actually runs — personal results from real builds, not an official leaderboard.
📺 Watch: Run Hermes Agent Free Forever, Here's how...!
What the Skill Has Actually Built
These are results from the hands-on video, not projections:
- A full website — built while Julian Goldie did nothing.
- A mini app — same story, no supervision.
- An analytics dashboard — same again.
The live demo is the clearest picture of how delegation behaves in practice. One ticket went on the board — "build a website about OpenClaw" — and the system triaged it into five subtasks, then worked through them automatically. One sentence in, a structured multi-step build out, with no human in the middle.
If you want a free autonomous coder making you money, check out the AI Profit Boardroom — the full Agent OS build plus the exact OpenCode delegation skill are inside. → Get the skill running on your machine
When to Use the Skill (and When Not To)
The sweet spot is any repeatable coding work — the stuff you keep meaning to build and never do:
- Landing pages — brief them in the morning, review them later.
- Mini apps — small tools that would otherwise eat an afternoon.
- Dashboards — the reporting views you have promised yourself for months.
It gets properly interesting when you batch. Stack tickets on the Kanban board and let Hermes work through the queue, delegating each build in turn. Scheduled workflows push it further still: the setup can even build something daily from Julian Goldie’s Obsidian memory, which turns the skill from a party trick into a production line.
When not to use it? If you are asking a one-line question about code rather than commissioning something, delegation is overkill — just ask the question. The skill earns its keep when there is an artifact at the end: a page, an app, a dashboard someone could actually open.
FAQ
Do I have to pay for anything?
No. Hermes is free and OpenCode runs on free models such as Big Pickle. The only real cost is the occasional rate limit, solved by swapping to another free option like Ling 3.0, OmniRoute or North Mini Code.
Do I need to edit config files or run terminal commands?
No. Go into Claude or Hermes and say, in plain English, that you want coding tasks delegated to OpenCode. The agent wires the skill for you.
What happens when a build fails?
Hermes retries it automatically, then verifies the artifact before calling the task done. Failure handling is part of the skill’s job, not yours.
Can tasks come from somewhere other than chat?
Yes. Tickets on the Kanban board inside the Agent OS trigger the same delegation loop, which is what makes batching — and scheduled daily builds — possible.
Will Hermes ever just write the code itself?
Not with the skill on. The profile is trained so every build goes through OpenCode — the Hermes-never-writes-the-HTML rule is the whole point of it.
The Bottom Line
The hermes opencode skill is a small switch with a large consequence. It turns Hermes from a chatbot that writes middling code into a manager that ships verified builds through OpenCode — monitored, retried on failure, checked before delivery, and all of it free. You enable it with one plain-English sentence, feed it through chat or the Kanban board, and the strict orchestrator-builder split keeps quality up and token spend down.
If your week contains repeatable coding work you keep postponing, switch the skill on, load the board before you log off, and see what is waiting for you in the morning.
