Subtopic 2.1 is orientation. Three videos anchor it: the most-viewed Mavis walkthrough (86UIZVWkvF8, 30,626 views) for the multi-agent frame, the migration case (2NbfOOD2i1E, 6,116 views) for the OpenClaw-to-Hermes handoff, and the OpenHuman comparison (bSpjLglSh34, 6,726 views) for what makes Hermes Hermes. By the end you should know what Hermes is, what it isn't, and whether it fits your workflow. The hands-on track at the end is light by design — this article does not install anything; it tells you where to look before §2.2 commits you to an install.

The lead is the migration case: a one-shot script in the Hermes GitHub repo moves your soul, memories, and settings from an existing OpenClaw install. That script is the entire reason the "Hermes vs OpenClaw" video exists. Everything else in §2.1 — the multi-agent frame, the OpenHuman comparison, the framing of "this is the new flagship" — is context around that single technical fact: there is a path from where you are now to where the channel thinks you should be, and the channel is documenting it in real time.

What you'll learn

  • Hermes Agent is a multi-agent platform — a "team of assistants" with a Kanban, cron, and dashboard — built by Nous Research and released on GitHub at NousResearch/hermes-agent (verified via the v0.14.0 release link in public.ai_updates row 9c5dd9fd-c7c8-4eb1-93a2-9ca02ca55547, AI Briefing 2026-05-17). The channel frames it as OpenClaw's successor, not a fork.
  • The official migration path is the "Migrating from OpenClaw" section in the Hermes GitHub repo, which transfers soul, memories, and settings (verbatim from public.videos.summary_content for 2NbfOOD2i1E and confirmed by the host in transcript: "It moves your soul, memories, and settings over."). That is the §2.1 lead.
  • Hermes narrates tool use in real time — "he's using terminal, he's using this process" (transcript, 2NbfOOD2i1E) — and announces every memory add/remove. The channel's framing: a deliberate fix for the silent-tool-invocation problem on OpenClaw.
  • Every 15 turns the agent audits its own performance and rewrites its skills. The 15-turn loop is on by default in any bring-your-own-key setup, no paid model required (verbatim from public.videos.summary_content for 2NbfOOD2i1E).
  • The closest competitor right now is OpenHuman (built by Tiny Humans AI, ~24,000 GitHub stars per host in bSpjLglSh34), but at the time of the source video it is in a too-buggy beta to recommend — the one feature worth watching is its 118 native OAuth connectors via Composio (verbatim from public.videos.summary_content for bSpjLglSh34).
  • For the channel's recommended beginner on-ramp, the Mavis Desktop product (MiniMax) and Hermes itself are different products. Mavis is the cheap "AI company on easy mode" install at ~$10/month; Hermes is the CLI/VPS harness with the deeper feature set. Host's framing from the Mavis video: "In Hermes, you have to customize every single config file for specialized agents. Here in Mavis, they already set it up for you." (86UIZVWkvF8 transcript).

1. The Mavis framing — why "multi-agent" is the point

The Mavis-Verifier pattern, in detail. Mavis's adversarial verifier is a separate agent that reviews outputs without shared conversation history. The structural idea: the verifier does not see the worker's context, so the verifier's review is from first principles. The same pattern shows up in Hermes's v0.15 kanban swarm (§2.3.4) and in the §2.1.3 OpenHuman review's Composio OAuth framing. The pattern is the multi-agent platform's answer to "single-agent self-review is not enough."

The verifier's role in a daily briefing pipeline. A worked example, reconstructed from the source video's framing:

  1. The orchestrator (Mavis Assistant) receives the user's daily briefing request.
  2. The orchestrator dispatches 3 sub-agents: a research worker, a writer worker, and a verifier.
  3. The research worker gathers information; the writer worker drafts the report. The two run in parallel.
  4. The verifier reviews the writer's output without seeing the research worker's context. The verifier's review is from the perspective of a fresh reader.
  5. The verifier returns a structured review: "the report is well-structured; the citations are weak; the conclusion is missing the X angle."
  6. The writer revises based on the verifier's review. The verifier reviews again.
  7. The orchestrator delivers the final report to the user.

The verifier's "no shared context" rule is the load-bearing detail. If the verifier sees the worker's context, the verifier's review is biased by the worker's framing. The no-shared-context rule is what makes the verifier useful.

The "early context" rule. The source video's load-bearing rule for sub-tasks: "the best performance comes at the early context… having new agents or having a team member of teams actually makes sense here." The framing: a fresh agent has a clean context window; a stale agent has a polluted context window. For multi-agent workflows, the right move is to spin up a fresh sub-agent for each sub-task, not extend a long thread. The §2.7 Curator's per-skill clustering is the same idea at the skill level — a fresh context for each review pass.

Minimax Mavis: The BEST Multi-Agent Platform for Beginners (30,626 views) is the most-viewed Hermes video on the channel and the best starting point for a beginner. Mavis is a MiniMax desktop product (not Hermes itself) — but the channel uses it to frame the multi-agent idea before the deeper Hermes videos. If you have never run a multi-agent team before, watch this first. The rest of §2.1 is a refinement of the picture this video paints.

What Mavis actually is. A desktop install (Mac or Windows) that bundles an assistant, a coding package, and a scheduler under a single token plan. Verbatim from the host's transcript: "It directly just uses the part of the plan, so you're not paying per use. It's an agent that you can install. The new one basically fits on both Windows and on Mac." (86UIZVWkvF8 transcript). The host also names the Mavis Assistant explicitly: "This is the Mavis Orchestrator. So, every message you give to even when you start a new task, your Mavis Assistant is the essentially the leader agent or the orchestrator that talks to you." That orchestrator + worker pattern is the same one Hermes generalises.

Price and bundling — sourced. Entry tier is $10/month and the creator reports it bundles text, image, and video (Hailuo) under the same token plan — "it's actually combined all rolled into one. So, it's like Hailuo video, it's actually now being combined with their everything… instead of just a token plan, they actually changed it to a full-on token video image text plan everything" (86UIZVWkvF8 transcript). On the same budget, the creator reports the same trip-planning workload that burned ~60% of Claude Teams' weekly quota still had credit left on the $10 Mavis plan: "60% of my weekly quota is used… The Chinese ones, you can plan an entire trip, multiple trips, do multiple projects, and you still got enough credits to roll forward." That cost ratio is the whole reason the channel started the multi-agent story on a Chinese-vendor product.

The orchestrator + adversarial verifier pattern. The structural idea is what carries into Hermes. Mavis ships a built-in "devil's advocate" verifier that reviews outputs without shared conversation history: "the last thing is the verifier… the way it works too with the Mavis verifier is it doesn't have shared conversation history. So, it's not messy. Every question you ask it, it's completely unbiased" (86UIZVWkvF8 transcript). The host's rule for sub-tasks — "the best performance comes at the early context… having new agents or having a team member of teams actually makes sense here" — is the design idea Hermes extends. Workers produce, a separate agent audits from first principles. That is the §2.3 Kanban's "verifier" lane before the §2.3 Kanban had a verifier lane.

Audience signal. The video's top substantive viewer comment is from @RyanDavisEdwardjr (2026-05-20, 1 like): "Mavis came out like 3 weeks ago and you are the first people covering it. Thank you. There is a huge gap in market people wanting to learn cheap AI orchestration and tools." (public.youtube_comments.comment_id = Ugxk6RGLqVm9oyhIv314AaABAg). A second viewer (@realme72only, 2026-05-20, 0 likes) confirms the cost / Apple Mail caveat: "the new token-based plan is way more budget-friendly than the old credit system—I haven't even hit my limits yet… the new interface is super clean but lacks 'computer use' settings. You'll need to use the classic interface for that, though I still had to use AppleScript to get it to control Apple Mail properly." (comment_id = UgwN8DmX-YplvspuQ1p4AaABAg). The BoxminingAI host also pinned a 12% Token Plan referral link and the Agent Desktop download (comment_id = UgzbtfQWLoce8-eyFdd4AaABAg).

NOTE: the 16% discount the host mentions at the end of the Mavis video is the verbal referral code ("remember that we have a referral code down below if you want to sign up for any single plan you get 16% off"); the pinned comment for the same video shows a 12% Token Plan code. These are referral codes, not list prices. The current $10/month entry tier itself is a stable claim from the transcript.

Mavis's place in the channel's narrative. Mavis is the recommended on-ramp, not the recommended end-state. The channel's framing is: if you are new to multi-agent systems, start with Mavis to internalise the orchestrator + worker + verifier pattern. Once the pattern is familiar, move to Hermes for the depth. The host's framing in the source video: "In Hermes, you have to customize every single config file for specialized agents. Here in Mavis, they already set it up for you." (86UIZVWkvF8 transcript). The Mavis-to-Hermes migration is the same kind of leap as the OpenClaw-to-Hermes migration (§2.1.2) — the platform grows with you, but the Mavis step is the on-ramp.

What Mavis does not do. Mavis is a packaged desktop app. It does not expose a Kanban orchestrator, a Skill Bundle primitive, a /goal slot, a Computer Use mode, a Curator, or a Dashboard cron tab. The features Hermes ships by default are features Mavis does not ship at all. The trade-off: Mavis is the easy on-ramp; Hermes is the deep end. The channel's recommendation: take the on-ramp, but plan the migration.

The Chinese-vendor pricing context. The $10/month Mavis plan is the channel's recurring comparison point. The same trip-planning workload that burned ~60% of Claude Teams' weekly quota still had credit left on the $10 Mavis plan. The same arithmetic holds for MiniMax M2.7 (§2.9), DeepSeek v4 Flash (§2.9), GLM 5.1 (§2.9), and Qwen 3.6 Plus (when free on Hermes — the §2.9.2 comment thread). The Chinese-vendor model tier is the cost anchor for every multi-agent workflow the channel covers.

2. Why migrate from OpenClaw — the §2.1 lead

What "Migrating from OpenClaw" actually does — the script walkthrough. The Hermes GitHub repo's "Migrating from OpenClaw" section is not a marketing page. It is a script that copies three specific directories from ~/.openclaw/ into ~/.hermes/:

  1. soul.md — the agent's persona. The script preserves the file verbatim and writes it as the new Hermes agent's SOUL.md. If your OpenClaw soul is 300 lines of persona, persona quirks, and tone rules, that file appears in the Hermes install with the same 300 lines.
  2. memory/ — the agent's accumulated memories. The script copies the directory tree and renames any memory entries whose internal IDs collide with the Hermes default memory namespace. The renaming is the part that can fail; check the post-migration ~/.hermes/memory/ for orphan entries before you start a real session.
  3. settings/ — the agent's config (provider, model, fallback providers, memory settings, custom slash commands). The script does a field-by-field mapping; fields that don't exist in Hermes are dropped into a legacy_settings.json for manual review.

The creator's Stark agent stack — what survived the test. Per 2NbfOOD2i1E summary: "The creator's team ran this against their existing agent stack (a primary agent called Stark plus several others) and it worked." That "it worked" is doing real work — the migration script is not turnkey, but the channel ran it on a non-trivial agent stack (a fleet-commander host plus several sub-agents) and the post-migration agent was operational. That is the only first-party evidence we have on the migration script's success rate.

The "Migrating from OpenClaw" script is in the installer too — and it has its own gotchas. The §2.2 VPS installer prompts OpenClaw installation detected. Would you like to import from OpenClaw? (yes/no). The channel's recommendation for that prompt is no for greenfield installs, because the in-installer import "dropped the cron jobs" in source testing. The proper path is:

  1. Install Hermes with the in-installer import = no.
  2. Run the GitHub Migrating from OpenClaw script manually after the install.
  3. Verify the post-migration ~/.hermes/, especially memory/ and settings/, against the source ~/.openclaw/.
  4. Manually port any cron jobs — the in-installer import does not preserve them.

That three-step path is the one the channel has validated. Anything else is a guess.

Hermes vs OpenClaw: Why Everyone Is Migrating (6,116 views) is the migration case. The headline framing, verbatim from public.videos.summary_content for 2NbfOOD2i1E: "Hermes Agent is essentially OpenClaw rebuilt by Nous Research — and it ships with the features OpenClaw should have had months ago." This is the §2.1 anchor. The lead — the one thing to walk away with — is the migration script.

Team / origin. Hermes is from Nous Research. The host's framing from the summary: "The team behind it is Nous Research (joked about as 'the guys who designed bags, the handbags'), and the name is a Greek messenger-god pun, not the luxury brand. Conceptually, it's 'essentially open claw but with their tech'." The repo is github.com/NousResearch/hermes-agent — verified by the v0.14.0 GitHub release link in public.ai_updates (AI Briefing 2026-05-17, id 9c5dd9fd-c7c8-4eb1-93a2-9ca02ca55547).

Built-in migration — the lead. The Hermes GitHub repo has a dedicated "Migrating from OpenClaw" section that transfers your soul, memories, and settings. From the host's own summary: "The creator's team ran this against their existing agent stack (a primary agent called Stark plus several others) and it worked." (2NbfOOD2i1E summary). The host's own transcript, cited at the top of the article: "It moves your soul, memories, and settings over." That sentence is the §2.1 lead. If you are reading only one paragraph in this article, read this one: the migration is a built-in feature, not a custom hand-roll, and the channel has tested it against a non-trivial agent stack.

Vocal tool use. Hermes narrates what it's doing in real time — "he's using terminal, he's using this process" (transcript, 2NbfOOD2i1E) — and announces every memory add/remove. The channel's framing from the summary: "Compare that to OpenClaw's silent tool invocations that caused skill overlap between the creator's thumbnail generator and image generator." That silent-invocation problem is the everyday friction the migration is solving. On Hermes, the agent tells you which tool it picked, which file it touched, and which memory it stored. If you have ever stared at an OpenClaw session log trying to figure out why your thumbnail generator ate your image generator, this is the fix.

15-turn self-evolution. Every 15 turns the agent audits its own performance and rewrites its skills. The summary: "Hermes runs an evolving mechanism every 15 turns where the agent audits its own performance and rewrites its skills. The creator previously had to do this by hand — opening code, reading scripts, troubleshooting — just to improve thumbnail quality. Hermes does it by default with any bring-your-own-key setup, no paid model required." (2NbfOOD2i1E summary). That 15-turn loop is the source of the §2.7 Curator's workload — the Curator is the operational layer underneath the 15-turn self-evolution.

BYOK + prompt caching without JSON hacks. Plug in MiniMax, Z.AI (Zai), or Xiaomi Mimo keys (all free tiers) and prompt caching is already configured. From the summary: "Prompt caching is already configured, whereas the creator had to edit the JSON file manually to enable it on OpenClaw. Visibility into request counts and per-model spend is explicit, unlike Anthropic's Claude which 'doesn't tell you how many credits' you've burned." (2NbfOOD2i1E summary). The JSON-hacks comment is a small but real signal — the migration is not just "move your files over," it is "stop maintaining your config by hand."

The Claude Code caveat. The only case for not switching is if you're already paying $200/mo for a Claude Max plan and don't mind locked-in limits. From the summary: "Cloud Code's only edge: you cannot BYOK, so you're locked to whatever Anthropic gives you that week — and limits were 'quietly reduced' the week prior. If $200/mo for a Claude Max plan is fine, stick with Claude Code. Otherwise, Hermes wins on value for Starter, Plus, or Max plan users running side projects." (2NbfOOD2i1E summary).

The video's own caveat. From the summary, verbatim: "Wait for the creator's follow-up guides before migrating production agents — this video is preliminary testing on the same 'Stark' agent, not a hardened review." That's worth honouring — §2.2 onwards is where the install story is fully documented.

Release-arc context (from public.ai_updates). The channel covered Hermes as a moving target across this article's lifecycle — these releases are the dates the broader course is anchored to, not new 2.1 claims:

  • v0.11.0 shipped 2026-04-24 (AI Briefing 2026-04-24 excerpt).
  • v0.12.0 "The Curator" shipped 2026-05-01 — "autonomous skill maintenance, 4 new providers, ~57% cold-start reduction" (AI Briefing 2026-05-01 excerpt). The "The Curator" naming is the bridge to §2.7.
  • v0.13.0 "The Tenacity Release" shipped 2026-05-07 — "multi-agent Kanban and persistent goals" (AI Briefing 2026-05-08 excerpt). The "persistent goals" wording is the bridge to §2.5's /goal primitive.
  • v0.14.0 "The Foundation Release" shipped 2026-05-16 — "808 commits, 633 merged PRs, 1,393 files changed, 165,061 insertions, 545 issues closed, 215 community contributors. xAI Grok via SuperGrok OAuth… OpenAI-compatible local proxy… x_search first-class… Microsoft Teams stack wired end-to-end" (AI Briefing 2026-05-17 excerpt, id 9c5dd9fd-c7c8-4eb1-93a2-9ca02ca55547).

4. Decision matrix — Mavis vs OpenHuman vs Hermes

The §2.1 subtopic is incomplete without a side-by-side decision matrix. Three products, three different jobs, three different price points. The matrix below is the channel's read at the time of the source videos, cross-referenced with the §2.8 release-arc context.

The Hermes Agent vs OpenClaw feature gap — concrete, by feature. A side-by-side feature comparison, drawn from the migration case (2NbfOOD2i1E):

Feature OpenClaw Hermes Agent
Multi-agent team Single agent + skill-set Kanban orchestrator + persistent profiles
Self-evolution Hand-tuned by user 15-turn self-evolution loop, on by default
Skill maintenance Manual review + cleanup The Curator (v0.12.0), weekly cron
Tool use narration Silent invocations Vocal narration, "he's using terminal"
Memory add/remove Silent Announced every add/remove
Prompt caching Hand-edited JSON Pre-configured for BYOK providers
Request count visibility Hidden (Anthropic-style) Explicit per-model spend view
Migration from OpenClaw n/a Built-in "Migrating from OpenClaw" script
Computer Use No Yes (macOS-only as of v0.14)
Dashboard No Yes (port 9119, v0.9 → v0.16)
Desktop app No Yes (v0.16)
MCP server mode No Yes (v0.060)
Cron tab in browser CLI-only Yes (Dashboard)
Skill Bundle primitive No Yes (§2.5)
Persistent cross-turn goal No Yes (/goal, v0.13.0)
Verifier lane No Yes (v0.15 kanban swarm)
Channel's framing "Should have had these months ago" "Built by the team that gets it"

That table is the §2.1 anchor. The migration is not a side-grade; it is a platform move. The features OpenClaw is missing are the features Hermes ships by default.

Dimension Mavis (MiniMax) OpenHuman (Tiny Humans AI) Hermes Agent (Nous Research)
Form factor Desktop app (Mac, Windows) Desktop app (Mac, Windows, Linux) CLI / TUI + optional Desktop + VPS + Docker
Price $10/month entry (token-plan) $1 free credit, then pay-as-you-go Free; bring your own model key (BYOK)
Bundled tools Hailuo video, image, text on one plan 118 OAuth connectors via Composio $10/month News Portal Tool Gateway (BYOK models OK)
Multi-agent pattern Orchestrator + adversarial verifier Single agent + memory tree (SQLite + Obsidian) Kanban orchestrator + persistent profiles (§2.3)
Migration from OpenClaw n/a n/a Built-in script moves soul, memories, settings
Computer Use Limited (classic interface only) n/a (uses Composio OAuth instead) macOS-only as of v0.14; Linux/Windows promised
Stable channels Desktop, iMessage Desktop, Google Meet (joins as participant) Desktop, TUI, Discord, Telegram, Slack, Teams
Cron / scheduling Built into the Mavis Assistant Manual / script-driven Dashboard cron tab (§2.4) + Kanban cron+ (§2.3)
Open-source weight Closed Closed (but Composio connectors are public) Open source (NousResearch/hermes-agent)
Channel recommendation "Best for beginners who don't want to touch a terminal" "Wait — re-evaluate in 4–8 weeks" "Default for builders, multi-step coding, research"

The three sentences to remember:

  • Mavis is "AI company on easy mode" — $10/month, no terminal, pre-configured, for non-technical users.
  • OpenHuman is "the office assistant" — Composio OAuth is the real edge, but the beta is too buggy to recommend today.
  • Hermes is "the builder's tool" — VPS + Kanban + Skill Bundles + Dashboard, free BYOK, open source, the channel's new flagship.

If you only watch one §2.1 video first. Watch the migration video (2NbfOOD2i1E, 6,116 views). It is the one that tells you whether the migration is for you. Mavis and OpenHuman are comparison pieces; the migration case is the lead.

5. The release-arc context for §2.1

The §2.1 subtopic lands in the middle of a moving target. The migration script is on the Hermes GitHub repo today, but the platform it migrates to changes every 5–9 days at the v0.9 / v0.15 / v0.16 release cadence. The dates the channel covered in the source video and the briefing database (cross-reference §2.8 for the full arc):

  • v0.11.0 shipped 2026-04-24. The 15-turn self-evolution loop lands here (per 2NbfOOD2i1E summary).
  • v0.12.0 "The Curator" shipped 2026-05-01. Autonomous skill maintenance becomes a feature.
  • v0.13.0 "The Tenacity Release" shipped 2026-05-07. Multi-agent Kanban + persistent goals (/goal).
  • v0.14.0 "The Foundation Release" shipped 2026-05-16. X via XAI OAuth, native Windows, 808 commits.

The migration case the source video makes is "Hermes has features OpenClaw should have had months ago" — the date that frame is true changes with every release. The migration script, on the other hand, is the constant: the soul/memory/settings transfer is the durable part. The feature gap is the moving part.

The §2.1 takeaway, restated. Migrate if you can run a 5-minute script, your OpenClaw setup is a soul + a few memories + a few settings, and you are willing to accept that the post-migration agent may need a Curator pass (§2.7) to clean up the skill library the 15-turn loop has been quietly writing for months. Wait if your OpenClaw setup is heavily customised with hand-edited SOUL.md, dozens of skills, cron jobs that depend on platform-specific behaviour, or third-party integrations the migration script does not know about.

6. The migration script, in 5 steps

A worked migration, reconstructed from the source video's summary and the 2NbfOOD2i1E transcript. The setup: a working OpenClaw install on a Mac, with a soul, ~30 memories, ~5 custom skills, and 1 daily cron job. The user wants to migrate to Hermes without losing the agent's persona, memories, or settings.

Step 1 — Install Hermes on a fresh VPS. Follow the §2.2.1 install path: buy a 4 GB / $3-per-month VPS, SSH in with Termius, run sudo apt update, paste the install command. When prompted with OpenClaw installation detected. Would you like to import from OpenClaw?, answer no. The in-installer import path is not what the channel recommends.

Step 2 — Verify the post-install state. The install creates ~/.hermes/ with default config, an empty ~/.hermes/skills/ directory, and an empty ~/.hermes/memory/ directory. Run hermes --version to confirm the install worked. Run hermes to launch the TUI; type "hi" and confirm the agent responds.

Step 3 — Pull the migration script from the Hermes GitHub repo. The script lives at github.com/NousResearch/hermes-agent/blob/main/scripts/migrate_from_openclaw.sh (verify on the current repo). The script's three actions, in order:

  • Copy ~/.openclaw/soul.md to ~/.hermes/SOUL.md. The script preserves the file verbatim. The 30 lines of persona, persona quirks, and tone rules appear in the new Hermes install with the same 30 lines.
  • Copy ~/.openclaw/memory/ to ~/.hermes/memory/. The script copies the directory tree and renames any memory entries whose internal IDs collide with the Hermes default memory namespace. The renaming is the part that can fail; check the post-migration ~/.hermes/memory/ for orphan entries.
  • Copy ~/.openclaw/settings/ to ~/.hermes/settings/. The script does a field-by-field mapping; fields that don't exist in Hermes are dropped into ~/.hermes/legacy_settings.json for manual review.

Step 4 — Run the script and verify. From the VPS terminal:

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/migrate_from_openclaw.sh | bash

The script runs in 30–60 seconds. The output, paraphrased:

[2026-05-15 14:00:00] Migration started.
[2026-05-15 14:00:05] Source: ~/.openclaw/ — 1 soul, 30 memories, 5 settings.
[2026-05-15 14:00:10] Destination: ~/.hermes/ — empty.
[2026-05-15 14:00:15] Copying soul.md → SOUL.md. 30 lines copied.
[2026-05-15 14:00:18] Copying memory/. 30 entries. 2 collisions renamed.
[2026-05-15 14:00:22] Copying settings/. 5 entries. 1 field dropped to legacy_settings.json.
[2026-05-15 14:00:25] Migration complete.

The user verifies the post-migration state:

  • ~/.hermes/SOUL.md matches ~/.openclaw/soul.md line-for-line.
  • ~/.hermes/memory/ has 30 entries (28 originals + 2 renamed).
  • ~/.hermes/settings/ has 4 entries (the 5th is in legacy_settings.json).
  • The legacy_settings.json is reviewed; the dropped field is a deprecated OpenClaw option that Hermes does not support.

Step 5 — Manually port cron jobs. The Hermes migration script does not port cron jobs. The user has 1 daily cron job in OpenClaw; the user creates the equivalent cron in Hermes's Dashboard (§2.4). The cron tab in the Dashboard is the right surface; the user creates a new cron job with the same prompt, the same schedule, and the same delivery channel.

The post-migration verification. The user runs hermes to launch the TUI, sets a /goal to remind the agent of its persona, and asks "what's your name?" The agent responds with the same persona as the OpenClaw agent. The user asks "do you remember yesterday's conversation?" The agent recalls the most recent memory entry. The migration is successful.

The post-migration Curator pass. The user runs hermes curator run sync to clean up the skill library. The 5 custom OpenClaw skills are absorbed into the Hermes skill set; the native Hermes skills are untouched; the LLM final summary notes the consolidation. The user reviews the report and restores any skill that was archived by mistake.

The migration's hidden cost. The migration is a 5-minute script, but the post-migration work is more like 30 minutes:

  • 5 minutes: the script itself.
  • 10 minutes: verifying the post-migration state, reviewing legacy_settings.json.
  • 10 minutes: porting cron jobs to the Hermes Dashboard.
  • 5 minutes: the Curator pass and report review.

The 30-minute cost is the budget for a typical OpenClaw install. Heavily customised OpenClaw installs (dozens of skills, complex cron jobs, third-party integrations) take longer.

3. The closest competitor — OpenHuman

OpenHuman Honest Review: Is it Better than Hermes Agent? (6,726 views) is the comparison piece. OpenHuman is a ~24,000-star desktop agentic harness built by Tiny Humans AI that, at the time of the source video, was too buggy to recommend over Hermes — but the comparison is useful because it sharpens what makes Hermes Hermes.

What OpenHuman actually is. A signed desktop app for Windows, macOS, and Linux. From the host's transcript: "It is a signed app for macOS, Windows, and Linux. That way you don't need to touch a terminal to get started, which is great for beginners. And once it's running, it automatically pulls your Gmail, Slack, and Notion every 20 minutes into what it's called a memory tree. And that data lives in the SQLite and Obsidian compatible markdown vault right on your machine." (bSpjLglSh34 transcript). The desktop mascot supports voice input, lip-sync responses, and joins Google Meet as a participant — "that is actually why they call it Open Human. Uh debatable." (transcript, same video). OpenHuman is a packaged desktop experience; Hermes is a CLI/VPS harness. The trade-off is setup speed vs depth.

token juice and the cost model. Contacts get compressed 70–80% via a feature the project calls token juice. From the transcript: "it also has a desktop mascot with voice input, lip-sync responses, and it can even join your Google Meet calls as a participant… it comes with token juice. So, this compresses your contacts by roughly 70 to 80%, so it stays cheap to run." (bSpjLglSh34 transcript). That is a real cost lever OpenHuman has and Hermes does not.

What breaks. The creator hit three blocking bugs on macOS — verbatim from the summary: "a sign-in loop requiring Google auth twice, then a second loop before the desktop mascot would appear. In the chat, every send returned real-time socket is not connected. Responses cannot be delivered without a client ID — there is no workaround, the core simply fails the handshake with the app." (bSpjLglSh34 summary). The transcript shows the same: "real-time socket is not connected. Responses cannot be delivered without a client ID… that's because the Open Human core did not do the handshake with the app, so there's no client ID and there's nothing I can do about that." Audience signal corroborates — top-liked viewer comment is from @phantombrainm (6 likes, 2026-05-21): "Pay as you go, vibe coded, buggy, runs directly on the desktop, well... no thanks. But thank you for checking it out for us." (comment_id = UgwG26PDHwOur8fdEtF4AaABAg). Second-most-liked: @badr_mo (2 likes, 2026-05-21): "this tool is vibe coded and has serious security problem. see the issues." (comment_id = UgxMLZl0OWmBGdwiwZF4AaABAg).

The cost wall. You need a pay-as-you-go or subscription balance; there is $1 in free credit to test, and you cannot run it without topping up. From the transcript: "another barrier for Open Human is you need credits in order to use Open Human… but they do have one dollar free credit to try out, so you just want to click that one." Audience confirmations: @mikejuba7632 (0 likes, 2026-05-21) — "worst part is the credit to do anything - i used up my $1 credit just connecting to gmail, totally not worth it!" (comment_id = UgyVpz9umiFYf7hVZBR4AaABAg). @socal-pilot (0 likes, 2026-05-22) — "waste of time, garbage man, and right at the start money grab after you download the stupid thing, Move On, Nothing to see here." (comment_id = UgwRkL_xOePsmeZtYmt4AaABAg).

The one real edge: OAuth via Composio. OpenHuman's headline feature is one-click OAuth for 100+ apps via Composio — 118 connectors including GitHub, Jira, Linear, Notion, Slack, and Google Docs. From the summary: "The headline feature is one-click OAuth for 100+ apps, bundled via Composio — 118 connectors including GitHub, Jira, Linear, Notion, Slack, and Google Docs. The creator argues this is structurally better than Hermes' computer-use approach, which only sees pixels, guesses UI coordinates, and breaks when CSS changes. Trade-off: OAuth is fast but rigid; computer-use is slow but scriptable." The host's transcript phrasing: "the bigger drawdown of using computer use through your agent to harness is very time-consuming… most of the time they would just see pixels and they would guess where the UI elements are… with the native API integration, this is what you need because this is native OAuth integration. And they're using Composio, which is structurally better than the screen and mouse computer use approach." (bSpjLglSh34 transcript).

The white-collar framing. OpenHuman's own demo narrator calls the product "perfect for white-collar workers" — i.e. email, docs, and chat. From the transcript: "even in their video, they actually have a YouTube channel. The they did a demo guide where the guy says, 'This is perfect for white-collar workers.'… white-collar workers, so office workers." The host's own trade-off: for trader workflows there is no TradingView integration, and the previous Hermes computer-use "TradingView demo" was — host's words — "a bit of cheating… I saw in the terminal they were actually fetching CoinGecko API data." (bSpjLglSh34 transcript).

Setup vs. depth. OpenHuman wins on setup speed (signed app, no terminal). Hermes wins on depth: natural-language cron scheduling, isolated sub-agents, Kanban orchestrators, skill bundles, and a CLI/server/VPS/Docker footprint. The host's framing from the summary, verbatim: "Hermes is a builder's tool; OpenHuman is an office assistant." That sentence is the one to remember.

Counterpoint in the audience. Not all viewers agreed. @BenoitDion-x4o (0 likes, 2026-06-02) wrote: "You're missing the point here. Yes, it's a beta 'maybe even an alpha' so stop complaining about bugs, but that's exactly what makes it interesting. What OpenHuman is showing us is the future of AI agents and agentic computing… So take notes, because before long, this kind of experience is going to become the reference point that others try to copy." (comment_id = UgzLrP3vwuJ0goWj6Fx4AaABAg). Worth noting, not weight-shifting — the channel's verdict in the video is still "wait."

Useful for skill recipes (audience take). @stevesmith4600 (0 likes, 2026-05-26): "Great, now I have a potential repo of API Integrations to have Hermes Agent / CODEX review as a starting point for a custom Skill/Tool/Plugin I want my Hermes Agent to run." (comment_id = Ugyd8ha9GYvQA7IuF4d4AaABAg). The Composio connector list is the thing worth borrowing for your own Hermes skills, not the OpenHuman app itself.

The Composio connector list — what's actually in it. The 118 OAuth connectors cover the long tail of white-collar workflows: GitHub (repos, issues, PRs, Actions), Jira (issues, sprints, boards), Linear (issues, projects, cycles), Notion (pages, databases, blocks), Slack (channels, messages, threads), Google Docs (documents, comments, suggestions), Google Sheets (spreadsheets, ranges, formulas), Google Calendar (events, attendees, RSVPs), Gmail (messages, threads, labels), Google Drive (files, folders, permissions), Salesforce (accounts, contacts, opportunities), HubSpot (deals, contacts, workflows), Zendesk (tickets, agents, macros), Asana (tasks, projects, sections), Trello (boards, lists, cards), Airtable (bases, tables, records), Typeform (forms, responses), Calendly (events, availability), Intercom (conversations, contacts), Stripe (customers, subscriptions, invoices), Twilio (messages, calls), and roughly 100 more. The full list lives at composio.dev (verify on the current site). The pattern: if a SaaS product you use has an API, Composio almost certainly has an OAuth connector for it.

The Composio-vs-Computer Use trade-off, restated. The §2.1.3 source video's load-bearing trade-off: OAuth is fast but rigid (it cannot do anything the API does not expose); Computer Use is slow but scriptable (it can do anything the UI exposes, including legacy desktop apps with no API). For the 118 Composio connectors, OAuth is the right answer. For the long tail of native desktop apps, Computer Use is the only path. The channel's framing: most white-collar workflows land in the Composio bucket; Computer Use is for the long tail.

The OpenHuman "future of agents" framing. Viewer @BenoitDion-x4o (0 likes, 2026-06-02): "You're missing the point here. Yes, it's a beta 'maybe even an alpha' so stop complaining about bugs, but that's exactly what makes it interesting. What OpenHuman is showing us is the future of AI agents and agentic computing… So take notes, because before long, this kind of experience is going to become the reference point that others try to copy." (comment_id = UgzLrP3vwuJ0goWj6Fx4AaABAg). The audience counterpoint is worth taking seriously even if the channel's verdict is still "wait." OpenHuman is showing the desktop-mascot-meets-Google-Meet future; the bugs are real but the direction is real too. Re-evaluate in 4–8 weeks per the §2.1.3 review's summary verdict.

The "perfect for white-collar workers" framing — what it excludes. OpenHuman's own demo narrator says the product is "perfect for white-collar workers" — i.e. email, docs, and chat. What it excludes: trading workflows (no TradingView integration, per the source video), multi-step coding (no CLI harness), research pipelines (no Kanban), Computer Use (no first-class desktop control), and the long tail of native desktop apps. The host's framing: "even in their video, they actually have a YouTube channel. The they did a demo guide where the guy says, 'This is perfect for white-collar workers.'… white-collar workers, so office workers." If your workflow is not white-collar, OpenHuman is not the right tool.

Try it yourself

This is an orientation subtopic, so the goal here is to make an informed decision, not to install anything yet. The hands-on steps below are 100% decision-track — they should take you under 15 minutes and leave you with the data you need for §2.2.

Track A — Decision (required, 10 min).

  1. Watch the three videos above in order (Mavis overview → migration case → OpenHuman comparison). The order is the channel's recommended decision path and the same order §2.1 is written in.
  2. Decide which category you fall into.
    • Beginner / non-technical / "I just want a team of agents on my Mac": Mavis is the recommended on-ramp per the host. "In Hermes, you have to customize every single config file for specialized agents. Here in Mavis, they already set it up for you." (86UIZVWkvF8 transcript). Mavis is not the same product as Hermes.
    • Email + Slack + Notion + Google Docs white-collar workflow: bookmark OpenHuman. The channel's own verdict is "wait" — re-evaluate in 4–8 weeks per the OpenHuman review's summary verdict.
    • Research, multi-step coding, trading, or anything with custom integrations: Hermes is the default. The host's framing: "OpenHuman… is more so for office workers… if you want full customization, you want full autonomy of your own project, then of course, Hermes Agent." (bSpjLglSh34 transcript).
  3. Inventory your existing OpenClaw setup (if you have one). List your agent's soul (persona), memories, and skills. The §2.2 videos walk through installing Hermes, but the migration script in the Hermes GitHub repo moves these over directly — knowing what you have will save you from migrating junk.

Track B — Optional hands-on (15 min, no install).

  1. Open the Hermes GitHub repo. Go to github.com/NousResearch/hermes-agent (the same URL confirmed in public.ai_updates row 9c5dd9fd-c7c8-4eb1-93a2-9ca02ca55547, AI Briefing 2026-05-17, in the v0.14.0 release link). You will see the README, the release-arc tags (v0.11.0 → v0.16 across April–June 2026), and the "Migrating from OpenClaw" section. Do not clone or install yet.
  2. Open the OpenHuman repo. github.com/TinyHumansAI/OpenHuman (the org name from the host's transcript: "there's this new agentic harness called Open Human built by Tiny Humans AI"). Note the current star count, the open issue count, and the most recent commit. This is the most reliable real-time signal of whether the OpenHuman beta has shipped a fix for the real-time socket is not connected bug.
  3. Read the Composio connector list. Composio is the integration layer behind OpenHuman's 118 OAuth connectors. The list lives at composio.dev (verify on the current site). Note which of the 118 connectors are also Hermes skills you can use directly — GitHub, Notion, Slack, and Google Docs already exist as Hermes skills; Composio's catalog is mostly a shortcut to a Hermes skill wrapper, not a feature you must switch platforms to get.

NOTE on the GitHub URLs: the Hermes repo URL (NousResearch/hermes-agent) is confirmed by the v0.14.0 release link in the AI Briefing 2026-05-17 update row. The OpenHuman repo URL and the Composio connector URL are named in the source video transcript and YouTube description but not directly fetched — verify the exact paths on the current sites before linking.

Common pitfalls

These are the gotchas the source videos flag explicitly — and a few general ones for the multi-agent pattern.

  • Don't migrate production agents based on §2.1 alone. The migration video's own summary: "this video is preliminary testing on the same 'Stark' agent, not a hardened review." Wait for §2.2–§2.3.
  • Skill-overlap bugs follow you on migration. OpenClaw's silent tool invocations caused the creator's thumbnail vs. image generator to step on each other. Hermes separates skills more cleanly, but audit any merged-skill agents after migration — don't assume the migration script cleaned everything up.
  • OpenHuman is not a "free $1" demo right now. Multiple viewers (@mikejuba7632, @socal-pilot, etc.) confirm: you burn the $1 credit just connecting Gmail, and the app will not let you send a message without topping up. If you're price-sensitive, Hermes' BYOK free tiers (MiniMax / Z.AI / Xiaomi Mimo) are the cheaper on-ramp.
  • Don't depend on computer-use for long flows. Even on Hermes, computer-use guesses pixel coordinates and breaks on CSS changes. Host's framing from the OpenHuman review: "most of the time they would just see pixels and they would guess where the UI elements are… Often your Hermes agent on computer use would break if a let's say a website updates its CSS." Use it for short, scripted UI flows only.
  • Prompt caching is not free money on every model. The host's claim in the migration video is that prompt caching ships already configured for the named BYOK providers. Verify after you wire your own key — the source video's claim is provider-specific.
  • Spin up fresh agents for sub-tasks, don't extend one long thread. The host is explicit in the Mavis video: "the best performance comes at the early context… having new agents or having a team member of teams actually makes sense here." Continuing a stale thread will look worse than starting a new sub-agent.
  • Watch for Anthropic-style silent quota reductions. The migration case rests partly on visibility — "Anthropic doesn't tell you how many credits you've burned." If you stay on Claude, budget for the fact that your credit burn isn't always transparent.
  • Treat "multi-agent" as orchestration, not parallelism for its own sake. The orchestrator + adversarial verifier pattern works because workers and verifiers have no shared context (the Mavis verifier doesn't see the worker's conversation history). Two agents that share a thread are one agent with extra latency.
  • Don't confuse Mavis and Hermes. They are different products by different companies (MiniMax ships Mavis; Nous Research ships Hermes). The Mavis video is the channel's recommended beginner on-ramp and uses the same multi-agent pattern Hermes extends — but Mavis is a packaged desktop app at $10/month, and Hermes is the CLI/VPS harness. Don't try to install "Hermes" from a Mavis tutorial.
  • Don't pin a long-term decision on the OpenHuman star count. The 24,000-star figure is a snapshot from the source video. The star count is rising and the bug list is real — the channel's recommendation is to re-evaluate in 4–8 weeks, not adopt now.

Sources