I Put A Free AI Dev TeamOn A Kanban Board
Hermes Agent runs the board. OpenCode does the typing. OmniRoute routes every call to free models. I dropped three build tickets on the board, walked away, and came back to a landing page, a content kanban app, and an analytics dashboard — all verified, all free.
I was you. Then I gave the agents a board.
Before
Every build meant me sitting there, feeding one agent one prompt at a time.
I would paste a prompt, wait, check the file, paste the fix, wait again.
Three builds meant three babysitting sessions — and a token bill for every keystroke of boilerplate.
The agents were strong. The workflow was me being a human message queue.
Then I connected OpenCode to Hermes and gave them a kanban board.
After
Now I write tickets, not prompts.
Hermes claims each ticket, drives OpenCode to do the typing, and verifies the file before marking it done.
Every model call routes through OmniRoute's free lane — the bill for all three builds was $0.00.
I reviewed finished pages instead of watching a cursor blink.
You can have this too. Same tools. Same board. Zero API bills.
Commit to transitioning today. Not tomorrow.
You have seen the proof above. Real people. Real results.
The next ten minutes show exactly how I wired a free dev team into a board that runs without me.
So here is the deal.
Promise yourself one thing right now: you will finish this guide AND put one ticket on your own board before you sleep tonight. Just one ticket. Because the moment your first build ships while you are doing something else, everything about how you work with AI changes.
The people sitting still are getting passed. The people implementing today are the ones who will look back in six months and say "that was the moment."
Be one of those people.
Commit to the transition. Commit to taking action today. This changes your whole workflow.
The Free Build Line™ — tickets in, builds out
This is an assembly line with five stations. You only ever touch the first one.
The trick that makes it work: Hermes never writes the HTML. Its profile carries one standing order — every build goes through OpenCode, then Hermes verifies the artifact (real size, real closing tag) before the ticket moves. Orchestrator and builder stay separate, exactly like a real team.
Prompt babysitting vs ticket writing
- One agent, one prompt, one build at a time
- You are the message queue between ideas and code
- Every retry is you noticing, then re-prompting
- Tokens billed for every line of boilerplate
- Tickets on a board — the dispatcher does the claiming
- Hermes drives, OpenCode types, OmniRoute pays $0
- Failures retry themselves; blocked tickets tell you why
- You come back to verified files, not chat logs
The exact wiring. Copy it.
Point everything at OmniRoute.
OmniRoute is a local router that fronts 452+ models — 90+ of them free — behind one OpenAI-style endpoint on localhost:20128. Both tools below talk to it, so neither ever bills you.
OpenCode config (~/.config/opencode/opencode.json) gets a provider with baseURL http://localhost:20128/v1, and its free build model is omniroute/auto/coding.
Give Hermes a profile whose only job is driving OpenCode.
# ~/.hermes/profiles/opencode/config.yaml
model:
default: auto/coding:free # OmniRoute's free coding lane
provider: openrouter
base_url: http://localhost:20128/v1
api_mode: chat_completions
toolsets:
- hermes-cli
terminal:
backend: local
cwd: ~/freeclaude-scratch/hermes-opencode
gateway:
enabled: false # workers stay headless — see trap #1
platforms: {}Then the standing order, in the profile's AGENT.md: never write HTML yourself — run opencode run -m omniroute/auto/coding "<the build prompt>", verify the file is real (over 3KB, ends with </html>), and re-run OpenCode with the failure described if it is not.
Create the board, drop the tickets.
hermes kanban --board hermes-opencode boards create
hermes kanban --board hermes-opencode create "Beautiful SaaS landing page" \
--body "Build landing.html — dark, animated, gorgeous" \
--assignee opencode \
--workspace dir:~/freeclaude-scratch/hermes-opencodeRepeat for every build you want. Tickets carry the full spec, the assignee, and where the file must land.
Dispatch, then go do literally anything else.
hermes kanban --board hermes-opencode dispatch --max 3
hermes kanban --board hermes-opencode list # watch tickets moveThe dispatcher spawns one Hermes worker per ticket. Each worker reads its ticket, drives OpenCode, verifies the artifact, and marks itself done — or blocks with the reason in its log.
Three tickets in. Three builds out. $0.00.
These are the actual artifacts from the board run above — click any card to open the live build — built by OpenCode on OmniRoute's free lane, verified by Hermes, untouched by me.
real screenshot · the board after the run — every ticket moved by an agent, not by me
Why your workers will crash — and the 30-second fixes
My first three dispatches all died instantly. Every crash was a config trap nobody documents. Here they all are.
A kanban worker inherits your full Hermes stack by default — including the API server and every chat platform. If your main gateway already owns that port, the worker crashes at startup with nothing in the ticket but "pid not alive".
Fix: the profile disables all of it — gateway: enabled: false and platforms: {}. Workers should be headless builders, not chat servers.
Hermes has no provider by that name, even though the endpoint IS OpenAI-compatible. The worker exits before its first API call.
Fix: declare it as provider: openrouter with api_mode: chat_completions — that pair speaks plain OpenAI-style chat against any base URL you give it.
This one is nasty: the yaml base_url alone is not enough. If the profile's credential store has an openrouter entry without its own base_url, workers fall back to the real OpenRouter endpoint — where the free lane's model name does not exist, so every call 400s: auto/coding:free is not a valid model ID.
Fix: the credential entry itself must carry the gateway address. Easiest path: set up one working OmniRoute profile once, then reuse its credential entry in any new profile. Sixty seconds, permanent fix.
Agent infrastructure fails at the seams, not the models. All three traps were wiring — and once wired, the same board has run every build since without me.
"Free models can't build anything good," and other lies
"Free models produce toy output." — every AI pricing page, implicitly
The truth: OmniRoute's free coding lane routes to tool-capable coding models that shipped all three builds above. Scroll up — those screenshots are the free tier.
"Two agents talking to each other is a gimmick."
The truth: the separation is the feature. The orchestrator verifies what the builder claims — my workers rejected and re-ran builds that came back undersized, with no human in the loop.
"I'd need a server and a DevOps weekend."
The truth: this is one laptop, one yaml file, one markdown file, and four CLI commands. The whole wiring is printed above.
Want the board, the profile, and the prompts done for you?
Everything in this guide — the Agent OS, the kanban workflows, the free-model routing, the weekly live builds — is taught hands-on inside the AI Profit Boardroom.
