Three agents, one horse, three very different outcomes.
I gave OpenClaw, Hermes Agent and OpenCode the same prompt, the same model and the same task: build an interactive Three.js horse that can walk. One finished in ten minutes. Another needed four attempts, an upgrade and a harness patch.
Click any screenshot to open the gallery.
Why I ran this test.
I have been using OpenClaw since a few days after it was born. The hype was there; the results, not so much. I first ran it on an old Debian laptop, then moved it to a VPS. The best way to interact with it, I found, was through Telegram. The setup was a pain in the ass: I basically needed another AI to set up this AI. Every update, something broke, and I had to manually bring it back to life. After a few days, the hype faded and I stopped using it.
Then I tried Hermes. Hermes just got things done. No setup issues, nothing. It is so proactive that it even creates new skills automatically based on the tasks you give it.
This is a small example of what I mean.
On an old laptop or desktop, these agents are much more useful: the system interface is there from the start, so they can practice computer use, and fewer captchas appear while they browse the web because of the residential IP. Even better if you have a Mac you are not using.
One prompt, no extra instructions.
The task was intentionally small enough to finish in one sitting, but open-ended enough to expose how each harness handles a real build: read files, write code, run a browser, check the result and keep going.
Generate a horse in threejs, then show me the output in an interactive local website, the horse needs to be able to walkSame model every time: deepseek-flash via the direct DeepSeek API. No fallback models, no OpenRouter, no model switching in the middle of a run.
Important context
Both OpenClaw and Hermes have been personalized for weeks: custom skills, memory, channel wiring and personal instructions. I used fresh sessions and workspaces for this test, but neither harness was a clean install. That is unrelated to the code task itself, and it is one reason this is a field test rather than a lab benchmark.
Same model. Three different machines of execution.
Ubuntu 26.04.1 LTS, 4 vCPU, 7.6 GiB RAM. Both ran headless on the same host, with API calls over the network. The hostname says “2gb”; the actual RAM is 7.6 GiB.
MacBook Air M3, 8 cores (4 performance + 4 efficiency), 16 GB RAM, macOS 27.0.1. The visual checks used headless Chrome at 1440×900, DPR 1.
That machine difference matters. Hermes and OpenClaw had to work through a remote shell; OpenCode was sitting on the same laptop as the browser and could iterate on the page locally. The comparison is about workflow, not a controlled CPU benchmark.
The numbers behind the three demos.
| Metric | OpenClaw | Hermes | OpenCode |
|---|---|---|---|
| Version | 2026.10.3 → 2026.10.8 | 0.22.5 | 1.19.3 |
| Attempts | 4 (3 failed) | 1 | 2 build prompts |
| Time to final result | 19m 49s (successful run) · 43m 22s total | 10m 16s | 23m 13s build · 29m 58s session |
| Time to first working render | ~2m 06s | ~1m 59s | 4m 48s |
| Tool calls | 194+ known · 18 failed | 67 | 180 |
| Custom LOC | 765 · 606 effective | 795 · 641 effective | 1,934 · 1,607 effective |
| Output tokens | 70.2k known | 90.2k · 43.4k reasoning | 66.9k · 130.8k reasoning |
| Cache read | 11.81M | 6.17M | 16.97M |
| Reported cost | Not reported · ~$0.19 estimated | $0.0808 | $0.1804 |
| Result | Finished only after AGENTS.md rules | One-shot success | Success after visual iteration |
LOC excludes the vendored Three.js build, README files and screenshots. “Effective” lines exclude blank and comment-only lines. OpenClaw’s 43m 22s total includes three failed attempts; its final successful attempt was 19m 49s. OpenCode’s build time covers two prompts: the initial horse and a later pass that asked for the same green meadow background as OpenClaw’s final result, plus visual polish. First-render times for OpenClaw and Hermes were not in the CLI completion logs; they come from the first browser screenshot artifacts. OpenClaw’s is from the successful fourth attempt; both kept iterating after that first frame.
OpenClaw needed four attempts.
The first run looked promising. OpenClaw downloaded Three.js, vendored the modules and started planning the scene. Then the session sat in processing for twenty minutes with no new files. I killed it and started clean.
| # | Setup | Time | Tool calls | Output | Stop reason | What it left |
|---|---|---|---|---|---|---|
| 1 | OpenClaw 2026.10.3 · default | 20m 33s | — | — | stalled | Only vendored Three.js files |
| 2 | OpenClaw 2026.10.3 · clean retry | 56s | 5 · 1 failed | 8.7k | length | Only vendored Three.js files |
| 3 | OpenClaw 2026.10.8 · default | 1m 55s | 4 · 0 failed | 8.6k | length | package.json, no site |
| 4 | OpenClaw 2026.10.8 · AGENTS.md rules | 19m 49s | 185 · 17 failed | 52.9k | stop | Complete, working site |
The second attempt gave the clearest signal: OpenClaw stopped with stopReason: “length” after exactly 8,192 output tokens. It had already written files and used tools, so the harness did not treat the run as safely retryable. It simply ended.
I upgraded OpenClaw from 2026.10.3 to 2026.10.8. The release notes mention a fix for continuing unfinished tool work after an empty length-limited response, but this case was not empty: the model had produced a partial answer. The third attempt stopped at 8,576 output tokens with only a package.json to show for it.
The fix was not another model. It was changing the agent’s execution rules. I replaced the workspace AGENTS.md with a short set of instructions aimed at the tool loop:
- Tool-first: call a tool immediately for coding tasks.
- Never stop at “I will…” or a plan.
- Write files in chunks of at most ~120 lines.
- Never put a giant heredoc in a single tool call.
- Limit verification loops; stop only when the page returns HTTP 200.
With those rules, OpenClaw completed the same prompt in 19m 46s, using 185 tool calls. It was a real result, not a toy stub: a procedural horse, a walking gait, a scene with grass and trees, and a local server. But it took four attempts and a harness change to get there.
Hermes finished on the first try.
Hermes did what the prompt asked, in one session, with no configuration changes. It used 67 tool calls, wrote 795 lines of custom code and finished in 10m 16s. The result included a procedural horse, an IK-style gait, a control panel, a README and screenshots.
What stands out is not that it wrote fewer lines. It is that it kept the work inside the output budget. It split the build into smaller tool calls, used its own reasoning tokens to plan, and did not try to emit an entire 22 KB file in a single response. The final answer reported the gait behavior and the checks it had run.
The takeaway
Same model, same API, same host. The difference was the harness: how it budgets output, how it chunks tool calls and what it does when the model hits a limit.
OpenCode was the most polished, thanks to a second prompt.
OpenCode ran on the Mac, with the same DeepSeek model and a local browser for visual checks. The first prompt produced a working horse and the first verified render at 4m 48s. That was slower than the first screenshots from the VPS runs, but a first frame is not a finished site.
Then I asked it to add the same green meadow background as OpenClaw’s final result and do a visual polish pass. That second prompt is where most of the time went: 17m 18s, 70 model steps and 143 tool calls, with 44 browser screenshots generated during QA. The final version is the most polished of the three: 1,934 lines of custom code, a stylized low-poly horse and a proper scene with grass, trees, hills and polish.
This is not a clean one-shot comparison. OpenCode had a second prompt and a local browser, and the Mac is a different machine from the VPS. I am including it because it shows a different point in the trade-off: a human-in-the-loop visual iteration can produce a better-looking result, but it is no longer the same test.
The model was not the bottleneck.
Hermes and OpenClaw used the same model. One finished in 10 minutes; the other needed four attempts. The difference was how each harness handled output limits, tool loops and file writes.
A model can be cut off at 8,192 output tokens. If the harness treats that as a normal ending, the task dies silently. The fix is continuation, smaller writes or a larger output budget — not necessarily a better model.
All three had pixels on screen in under five minutes: OpenClaw in about 2m 06s, Hermes in 1m 59s, OpenCode in 4m 48s. But a first render is not a finished task: Hermes finished in 10m, OpenClaw needed four attempts and 43m total, and OpenCode spent 23m on polish.
Both OpenClaw and Hermes carry weeks of custom skills and memory. That is useful in daily work, but it makes clean comparisons harder. Treat this as a field report, not a leaderboard.
What this test is not.
- One run per harness. These are anecdotes with timestamps, not a statistical benchmark.
- Same model and API, but not the same machine: two VPS runs, one Mac run.
- OpenClaw changed versions during the test (2026.10.3 to 2026.10.8), and its final success required custom AGENTS.md rules.
- OpenCode had a second prompt asking for OpenClaw’s final meadow background plus a polish pass; its numbers are the full two-prompt build, not the one-shot result.
- Both OpenClaw and Hermes had weeks of personalization, custom skills and memory. The test used fresh sessions, not clean installs.
- Pricing depends on peak/off-peak rates and cache behavior. Treat the cost column as a rough estimate, not an invoice.
- Visual quality is my judgment. The sites were checked in a browser, but there is no automated design score.
The short version
For a one-shot, long-running coding task, Hermes was the most reliable harness in this test. OpenClaw can do the work, but it needs a harness configured for chunked tool use and output-limit recovery. OpenCode remains the best option when I want to sit next to the result and iterate on the visuals.