Engineering · Benchmarks

We made two AI agents compete for a day job. Same brain, very different employees.

Hermes and OpenClaw, running the exact same model on the exact same account, got the same four tasks: check my services, triage my email, read my week, look up my GitHub. One finished in 3 minutes. One never missed a calendar event. Then things got interesting — we let them share skills.

MyApi Engineering · July 18, 2026 · 9 min read

The setup: remove every excuse

Agent comparisons usually collapse under "well, it used a different model." So we removed the variable. Both agents ran GPT-5.4. Both ran self-hosted, on their own machines. And both connected to the same MyApi account — the same inbox, the same calendar, the same 23 connected services — through the same MCP interface.

The contenders:

• Hermes (Hermes Agent v0.18.0) — the veteran. It has worked with this MyApi account for months and, along the way, wrote itself a library of skills: little playbooks it authored after each mistake it made.
• OpenClaw (OpenClaw 2026.7.1) — the new hire. Installed the day before. Zero MyApi experience.

Getting them both connected took one enrollment code each. Neither machine ever received an OAuth token — each agent enrolls with a cryptographic device identity (an Ed25519 keypair, we call it an Agentic Secure Connection), and the gateway signs and proxies everything. That detail turns out to matter later, because it's also what made this benchmark measurable at all.

$ npx -y myapi-asc-mcp   # MYAPI_ENROLL_CODE=MYAPI-XXXX-XXXX
✓ device identity generated (Ed25519)
✓ enrolled as "Openclaw" — no OAuth tokens stored on this machine
✓ 23 services available through MCP

The tasks: a normal Tuesday

No puzzles, no trick questions — the boring, load-bearing work you'd actually delegate:

Every run used a brand-new session — no memory, no warm context. We measured four things: wall-clock time, model calls, tokens, and every single API request each agent made.

That last one is usually impossible to measure fairly — you'd be grepping two different agents' logs and trusting them. We didn't have to: MyApi's audit log records every request with the calling device's identity attached. Two agents, one account, and the server tells you exactly who asked for what, when:

timestamp                 device      action
2026-07-18T04:40:39.9Z    Hermes      service_proxy      gmail
2026-07-18T04:40:40.2Z    Hermes      asc_request
2026-07-18T04:38:26.1Z    Openclaw    service_proxy      github
2026-07-18T04:38:25.9Z    Openclaw    asc_request
2026-07-18T04:35:41.3Z    Openclaw    prompt_scan_skipped
…every request, attributed to the device that made it

Round 1: the sprinter and the auditor

Hermes won every race — 188 seconds total against OpenClaw's 478. On the GitHub task both agents produced the word-for-word identical (and correct) answer; Hermes just got there 66 seconds sooner.

The token bill was even more lopsided. Hermes runs a lean context and leans hard on prompt caching: its whole four-task day cost about 742k tokens. OpenClaw drags a ~60,000-token context into every one of its 48 model calls — its day cost several times that.

So OpenClaw just loses? Not quite. On the calendar sweep, OpenClaw returned all 33 events across all seven days. Hermes came back in nearly half the time — with 11 events, having silently skipped four days. If that's your week, "fast" is not the adjective you care about.

One counterintuitive number: Hermes made more API calls (88 vs 66). It fires many small, targeted requests and moves on; OpenClaw makes fewer, broader calls and burns its time thinking between them. Fewer API calls predicted neither speed nor quality.

Round 2: wait, this wasn't fair

Halfway through writing this up, we caught our own confound. Hermes wasn't just fast — it was experienced. Months of working this account had left it with self-authored skills full of hard-won specifics, like this gem from its Gmail playbook:

That's not intelligence. That's scar tissue. OpenClaw, installed the day before, had none.

So we leveled it. It turns out OpenClaw can learn the same way — we pointed it at its own round-1 transcripts and asked it to write itself a skill. It produced a genuinely good one (it even caught its own waste: "one task called GET /services twice; the second call added no value") and filed it through its built-in Skill Workshop. Then we reran everything.

Result: 8% faster, 23% fewer API calls. Helpful, not transformative — in three of four runs, OpenClaw never even opened the skill it had just written.

Round 3: just steal the veteran's playbook

Here's where it gets fun. Both platforms use the same skill file format. So we copied Hermes' nine battle-tested MyApi skills — months of accumulated experience — straight into OpenClaw's library. A file copy. Then ran everything a third time.

OpenClaw's behavior visibly changed. It consulted skills in three of four runs. Its email answer began with "Mailbox verified" — Hermes' signature move, learned from a months-old Hermes mistake, now executing on a different agent. And on the calendar sweep:

But zoom out and the totals barely moved: 478 → 442 → 434 seconds. Skills transferred the know-how; they couldn't transfer the architecture. OpenClaw still hauls that ~60k-token context into every model call, and no playbook fixes physics. Hermes stayed 2.3× ahead overall.

The validation run: everyone gets humbled

Hermes had only run once, so before declaring anything we ran its whole gauntlet again. Its efficiency reproduced almost exactly — 166 s total, with API calls, tool calls, and tokens all within ~10% of round 1. The speed is real.

But the rerun also swept the calendar perfectly: 33/33 events, in 66 seconds. Which proves round 1's 11-event miss wasn't a design limit — it was a flake. And that reframes everything:

Speed is Hermes' reliable trait. Completeness is OpenClaw's. Pick your poison — or run both, which is exactly what a shared gateway makes cheap to do.

What we actually learned

• "Same model" does not mean "same agent." Identical GPT-5.4, a 2.5× speed gap and a ~5× cost gap — all of it platform architecture: context size, caching strategy, call discipline.
• Experience is a file. The most surprising result: months of one agent's learned behavior transferred to a competitor via cp. Skills-as-files quietly become portable capital — and because both agents speak to the same MyApi surface, the playbooks were valid on arrival.
• Measure at the gateway, not in the agent. Every number in this article that involves API traffic came from one place: the audit log, attributing each request to a cryptographically-identified device. No agent self-reporting was trusted, and none was needed.
• Run your candidates on real work. Four tasks and an afternoon told us more than any leaderboard. n=1 caveats apply (we've flagged the flake we caught) — but the shape of the result was unambiguous.

Methodology: benchmark run July 18, 2026 (UTC). Both agents self-hosted on separate machines — Hermes Agent v0.18.0, OpenClaw 2026.7.1, both driving GPT-5.4 — fresh session per task, sequential runs. OpenClaw: three rounds (no skills / self-authored skill / plus Hermes' skill library). Hermes: two runs (original + validation). n=1 per task per run — treat timings as indicative. Token counts from each platform's session accounting; OpenClaw's runtime reports final-call usage only, so its total is estimated as model calls × context and marked as such. API calls counted server-side from the gateway audit log. Terminal panels are sanitized recreations; personal message and event details are withheld throughout.