The hermes opencode integration is the wiring diagram behind Julian Goldie's AI coding team: two agents, one Kanban board, and a single rule holding the whole machine together. One agent manages the work. The other writes every line of code. While Julian did nothing, the pair shipped a full website, a mini app and an analytics dashboard. This page is about the architecture — how the two agents are bolted together into an assembly line, and why the design matters more than either agent on its own.
Both agents run inside his Agent OS, and together they behave like a full AI coding team working 24/7. Here is how the pieces actually connect.
The Core Split: OpenCode Is the Brain, Hermes Is the Hands
Every production line separates planning from building. This one is no exception.
- OpenCode is the brain that writes code. It is an efficient open-source coding agent, and it can run on free APIs and free models. Every line of HTML, every script, every dashboard component comes out of OpenCode.
- Hermes is the hands. It is the orchestrator that manages the work: it watches the board, claims tickets, breaks them into subtasks, delegates the building, and checks what comes back.
Neither agent is the headline on its own. The headline is the split. A builder that never has to manage, paired with a manager that never gets to build, produces something neither could alone: a pipeline that keeps moving after you walk away.
How the Hermes OpenCode Integration Is Wired Together
The integration has exactly two connection points: a Kanban board and a command line. Understand those two and you understand the whole system.
The board is the message queue
Inside the Agent OS sits a Kanban board. This is where work enters the system and where its state lives. Tickets move through columns — to-do, in progress, done — and the agents read from and write to the board, not to you. That single change removes the biggest bottleneck in most AI workflows: you, sitting between the model and the next step, copying outputs and typing follow-ups.
The CLI is the handoff
When Hermes decides something needs building, it does not start typing code. It calls the OpenCode CLI and hands the subtask across. OpenCode produces the artifact and passes it back. Hermes then verifies the result before the ticket is allowed to move on. Dispatcher on one side, builder on the other, one clean handoff in the middle.
📺 Watch: NEW Hermes Agent Integration Update
The Five-Station Assembly Line
Here is the full journey of a ticket, station by station:
- You drop a ticket on the Kanban board. Plain English, inside the Agent OS. This is your entire job in the system.
- The Hermes dispatcher claims it and triages it. In Julian's live demo, the ticket "build a new website about OpenClaw" was split into five subtasks — research the SEO keywords, design the architecture, build it, and so on — each one moving from to-do into in progress on the board.
- OpenCode writes every line. Each build subtask is delegated through the OpenCode CLI. The orchestrator never touches the code itself.
- Failures retry themselves. A subtask that fails goes back on the board and runs again until it is done. There is no re-prompting by you at any point.
- Hermes verifies the artifact. Before the ticket moves on, the orchestrator checks that what OpenCode produced actually matches what the ticket asked for.
Notice who is missing after station one: you. The board carries the state, the dispatcher carries the workload, and verification happens before anything gets called finished.
The One Rule: Hermes Never Writes the HTML
Julian calls this the one thing you must do, and it is the load-bearing wall of the whole design: Hermes never writes the HTML.
His Hermes profile is trained so that every build goes through OpenCode. Orchestrator and builder stay separate, always. It sounds like a minor configuration choice. It is actually the difference between a system and an expensive mess.
Skip the rule and the failure mode is predictable. The orchestrator starts coding. It burns tokens doing the builder's job. And because the agent writing the code is now the same agent checking the code, the verification step quietly disappears — nobody is left to mark the homework. The whole system falls apart from that one shortcut, which is why the separation is trained into the profile rather than left to chance.
📺 Watch: Run Hermes Agent Free Forever, Here's how...!
Old Way vs New Way
The clearest way to see what the integration changes is side by side.
| Stage | Old way: one agent, one prompt | New way: the assembly line |
|---|---|---|
| Starting work | You type one prompt for one build, then wait | You drop a ticket on the Kanban board |
| Managing the queue | You are the message queue | The Hermes dispatcher claims and delegates |
| Throughput | One build at a time | Tickets triaged into subtasks that flow through the board |
| Handling failure | Every retry is a re-prompt from you | Failures retry themselves until done |
| Token cost | Tokens burned on every prompt you send | Building delegated to an agent that can run on free models |
| End of the day | A thread you have to pick back up | Finished, verified builds waiting for you |
The old way is not broken; it is just manual. You are the queue, the retry button and the quality check, all at once. The new way moves those three jobs onto the board, the dispatcher and the verifier — which is exactly why the builds keep flowing while you are somewhere else entirely.
If you want an AI assembly line making you money, check out the AI Profit Boardroom — the full Agent OS build and the OpenCode system Julian runs are inside. → Get your own dispatcher and builder running
📺 Watch: Higgsfield MCP Makes Hermes Agent Unstoppable
What the Integration Built While Julian Did Nothing
Proof beats theory. With the line running on its own, Julian Goldie came back to:
- A full website
- A mini app
- An analytics dashboard
- And a Kanban board — built via the Kanban board, which is about as recursive as productivity gets
All of it for free, and all of it without him writing anything beyond the original tickets. That is the point of the architecture: the output list grows while your input stays at one line per ticket.
Profiles, Schedules and the Rest of the Team
The board-and-builder loop is the core, but the same architecture stretches further in his setup:
- Separate Hermes profiles per model. Julian keeps one profile per model for testing, and Goldie Bench — his own hands-on benchmark, not an official leaderboard — is where he works out which models are actually worth a seat in the line.
- Scheduled custom workflows with nicer UIs. Hermes Oracle covers news. Hermes Astros watches competitors. One standing instruction is simply: "build an app every day based on my Obsidian memory and what would actually be useful".
- A lead-generation agent. The same orchestration pattern does outreach, writes campaigns and manages inboxes — a reminder that the assembly line is not limited to code.
Hermes and OpenCode FAQ
Isn't orchestrating agents hard?
This is the most common objection, and the honest answer is that Hermes does the heavy lifting. You do not manage agents; you write a ticket. The dispatcher claims it, triage happens on the board, delegation happens over the CLI, and retries happen without you. Orchestration is what the system does, not what you do.
What exactly does OpenCode bring to the pair?
OpenCode is the brain: an efficient open-source coding agent that writes every line, and one that can run on free APIs and models. In this architecture it does a single thing completely — build whatever the ticket needs, whenever Hermes delegates it via the CLI.
Why can't Hermes just write the code itself?
It could, and that is the trap. The moment the orchestrator codes, it burns tokens on builder work, and the verification step vanishes because the agent checking the artifact is the one that made it. That is why the profile is deliberately trained to route every single build through OpenCode.
What happens when a build fails?
The failed subtask stays on the board and retries itself until it is done. You are never pulled back in to re-prompt it. That, more than anything, is the difference between a chat window and a pipeline.
The Bottom Line
The Hermes OpenCode integration is not one clever agent; it is a disciplined division of labour. OpenCode is the brain that writes every line. Hermes is the hands that claim, triage, delegate and verify. The Kanban board replaces you as the message queue, failures retry themselves until they pass, and one rule holds the structure together: the orchestrator never writes the HTML.
Set it up once inside Agent OS, drop a ticket on the board, and come back to finished, verified builds — a website, a mini app, a dashboard, even a Kanban board built by the board itself. Your job is the ticket. The line does the rest.
