Hermes Agent — positioning it as the execution engine of the Second Brain

What is Hermes Agent

For individuals who use Obsidian heavily and are familiar with leading AI like Claude or Grok, Hermes Agent is positioned as "the execution engine of the Second Brain."

From a Karpathy-style LLM Wiki perspective, Obsidian is "the static layer that humans read and organize," while Hermes is "the dynamic layer that reads that knowledge to auto-execute, update, and learn." They complement each other.

Overview and positioning

Hermes Agent is an open-source self-improving autonomous AI agent released by Nous Research in February 2026 (MIT license). Tagline: "personal AI infrastructure that grows with you."

Status as of May 2026:

• Version: v0.14.0
• Underlying model: grok-4.3 via SuperGrok OAuth
• The official Obsidian skill is enabled by default
• Self-hosted only (no official managed cloud)

It's not just a chatbot — it has a closed loop of task execution → auto-skill generation → long-term memory update, and is structured to keep learning the user across sessions.

5 core features

>3-1Auto-generated reusable skills

Repeated work is automatically saved and refined as a SKILL.md. The second time you give the same instruction, Hermes recognizes "ah, this is the same pattern as before" and leaves behind a polished skill file. From the next time, a short instruction reproduces the same behavior.

>3-2Persistent memory mechanism

A combination of MEMORY.md / USER.md / SQLite realizes cross-session context retention and accumulation of user preferences. It remembers "you said this last time" and "this user writes like this."

>3-3Strict enforcement of tool use

Tool calls are mandatory by design — "draw up a plan and stop there" isn't allowed. It autonomously combines the Obsidian skill, browser operations, terminal execution, and more to complete tasks. This is the big practical difference from Claude alone.

>3-4cron / webhook support

As a resident agent, it natively supports scheduled execution and external event triggers. Automations like "check X every morning" or "process Y when it arrives in Gmail" are wired up out of the box.

>3-5Official Obsidian skill

Reads and writes the Vault directly, enabling two-way integration with your knowledge base. The standard pattern becomes: Hermes reads notes piled up in daily/ and writes results back to knowledge/.

>3-6Parallel multi-agent execution (delegate_task)

The built-in delegate_task tool lets a parent agent spin up child agents in parallel, each with its own independent context (ThreadPoolExecutor under the hood). In the 5/18 hands-on run, three Vault notes of different genres were dispatched to three children to summarize: the run completed in roughly 19.5 seconds across all three. Because children never see the parent's conversation history, context-cost is zero on the parent side. Per-child model overrides are supported, so a mixed-routing setup (light = grok-4-fast, complex = grok-4.3, review = Claude Opus) works out of the box. Children cannot call delegate_task themselves (no grandchildren), keeping things safe.

The value of parallelism isn't only speed — it's the "integrated meta-extraction" that only emerges from the parent's vantage point over multiple child outputs. The subagent-driven-development skill (from the OSS ecosystem) also ships a plan-driven workflow with built-in two-stage review (spec compliance / quality).

Differences from Claude / Grok and combined-use patterns

Claude (especially Claude Code) excels at high-performance instant reasoning, large-context processing, and high-quality code generation. Hermes Agent, on the other hand, shines at residency, automation, and self-growth.

The typical pattern adopted by many advanced users:

• Position Hermes as the orchestrator, delegating recurring tasks and long-term project management to it
• Call out to Claude / Grok when you need complex reasoning or high-quality output (via tool or manual handoff)
• Treat the Obsidian Vault as a shared knowledge source: Hermes writes execution results back to the Vault, and Claude reads them to do deeper analysis
• Expose Hermes itself as an MCP server via hermes mcp serve. Claude Code or Cursor can then call Hermes as a tool in the reverse direction, enabling a double-orchestration setup
• Multi-model fallback chain with hermes fallback add: when grok-4.3 hits rate limits or errors, automatically fail over to Claude / OpenAI / OpenRouter. With hermes proxy, the same SuperGrok contract can also back Codex / Aider / Cline / Continue

Current Hermes, running on SuperGrok OAuth + grok-4.3, combines Grok's strong reasoning as a base with the autonomy of a resident agent.

Why Obsidian integration matters

Obsidian is "the Second Brain that humans read and organize," Hermes is "the twin that reads that knowledge to auto-execute, update, and learn." Perfectly complementary roles.

Three reasons the integration matters:

• Hermes can read raw daily notes and knowledge MOCs accumulated in Obsidian directly and use them as material for skills and automation
• Feeding Hermes's execution results and learned insights back into Obsidian makes knowledge compound
• The user keeps managing all knowledge in the familiar Obsidian UI while delegating "execution" to Hermes, which dramatically lowers cognitive load

Operational tips

• Self-hosting recommended: there's no official managed cloud. Run on a cheap VPS (from $5) or serverless (Modal, Daytona) and pause idle hours to control cost
• Telegram / Discord integration: set it up as an always-on bot and you can give Hermes instructions from your phone
• Skill management habit: actively review the SKILL.md files Hermes generates and refine them by hand where needed. Treat auto-generated skills as a starting point
• Sync with Obsidian operations: keep daily/ as a rough input space and maintain MOCs in the knowledge/ layer. Pointing Hermes mainly at knowledge/ is more efficient
• Guardrails when combining tools: if you delegate long-running tasks to Hermes, set up periodic progress-check cron jobs. When combining with Claude, codify a rule that a human does the final output-quality check
• Know the 5 workflow-definition layers: Skill (reusable procedure) / Plan (implementation plan → auto-dispatch to sub-agents) / Cron (scheduled run) / Hooks (event-driven) / Script via RPC (zero-LLM-cost batch routines). The framework isn't Obsidian-specific — the same wiring applies to GitHub / Linear / email / any MCP-backed SaaS
• Zero-LLM-cost residents via --no-agent: passing --no-agent to hermes cron create runs a pure script with no LLM call. Disk / memory watchdogs and API health checks are perfectly served by this
• Inject project context with --workdir: cron jobs can auto-load AGENTS.md / CLAUDE.md. The same mechanism is what lets you straddle the Vault and a separate code repo
• Three patterns for automating the daily folder: ① auto-generated templates (empty INDEX in the morning) ② previous-day summaries (cron) ③ activity log (~/.hermes/hooks/post_write_file.sh auto-appending every write). They compose naturally

Known limits

• Because it's fully self-hosted, setup and operations carry a non-trivial technical burden
• An official visualization dashboard exists, but advanced node-graph features need to be built yourself via the Gitnexus skill or Mermaid
• When combining multiple AIs, context handoff and clarifying scopes of responsibility become operational challenges
• As of v0.14.0 the Obsidian skill integration is solid, but watch search performance once the Vault gets extremely large