I Rebuilt Hermes in Claude Code — It's Ridiculously Good

Three Hidden Costs of Off-the-Shelf Systems 1:00

Simon opens by examining the three hidden costs that emerge when you adopt any off-the-shelf AI agent system rather than building your own.

Inherited Assumptions

Every framework ships with embedded assumptions about how you work — your preferred tools, communication style, and workflow patterns. When those assumptions don't match yours, you spend more time fighting the tool than using it. These invisible constraints compound over time as the system shapes your behavior rather than the reverse.

Can't Fix What You Don't Understand

When something breaks in a system you didn't build, debugging becomes archaeology. Without deep understanding of the internal architecture, you're limited to surface-level fixes and workarounds. The opacity of someone else's design decisions creates a ceiling on what you can achieve.

Doesn't Scale Across Your Business

Generic solutions are built for the average case. As your specific needs grow and evolve, the gap between what the tool provides and what you actually need widens. Customization points offered by frameworks rarely align with the exact extension points your workflow demands.

The Identity Layer — What Hermes Nails 4:00

Simon highlights what makes Hermes genuinely special compared to other agent frameworks: the identity layer. This is the concept that makes the agent feel like your agent.

memory.md & user.md

At the core of Hermes's identity system are two files — memory.md and user.md — that get injected into every conversation. These files contain the agent's accumulated knowledge about who you are, what you prefer, and how you work. They evolve over time as the agent learns from interactions.

Designed for One Individual

Unlike multi-tenant platforms, Hermes is architecturally designed to serve a single person deeply. This philosophical choice enables a level of personalization that generic systems fundamentally cannot match. The agent doesn't just remember your preferences — it builds a persistent model of your working style, projects, and goals.

"The identity layer is the thing that separates Hermes from just being another wrapper around an API call."

The Memory System — What Could Be Better 6:00

While praising the identity layer, Simon offers constructive critique of Hermes's memory system and identifies areas for improvement.

• Retrieval granularity — the current system can surface too much or too little context depending on the query, making recall inconsistent
• Memory staleness — older memories don't always get updated or deprecated when circumstances change, leading to outdated context being injected
• Cross-session coherence — maintaining a coherent narrative across many sessions remains challenging, especially for long-running projects
• Structured vs. unstructured — the balance between free-form memory notes and structured data could be improved for better machine readability

These aren't dealbreakers — they're the natural growing pains of a system that's solving a genuinely hard problem in a novel way.

Building Your Own Alternative 8:00

Simon walks through his process of rebuilding key Hermes concepts inside Claude Code, sharing the practical decisions and tradeoffs involved.

• Start with the identity files — replicate the memory.md/user.md pattern first, as this provides the highest value-to-effort ratio
• Use Claude Code's native hooks — leverage CLAUDE.md and project-level instructions to inject persistent context without custom infrastructure
• Custom commands for workflow automation — build slash commands that encode your specific workflows rather than relying on general-purpose tools
• Iterative refinement — treat the system prompt and identity files as living documents that improve with every session

The key insight: you don't need to replicate all of Hermes — just the pieces that matter most for your workflow.

Architecture Comparison 11:00

A side-by-side comparison of the architectural approaches between Hermes and a Claude Code-based rebuild.

• Hermes — full-featured agent runtime with skill system, multi-provider support, plugin architecture, session management, and cross-platform delivery (Telegram, CLI, etc.)
• Claude Code rebuild — lightweight, leverages Claude Code's built-in tool use and terminal access, relies on CLAUDE.md for identity, and trades features for simplicity
• Memory persistence — Hermes uses SQLite-backed session search and structured memories; the rebuild uses flat files and git-tracked markdown
• Tool ecosystem — Hermes has a curated tool set with browser, vision, and specialized integrations; Claude Code has terminal and file access with MCP extensions

Neither approach is universally better — the right choice depends on whether you value completeness or simplicity, and how much infrastructure you're willing to maintain.

Verdict & Recommendations 13:00

Simon delivers his final assessment, positioning when each approach makes sense and who should consider which path.

• Use Hermes if you want a batteries-included personal agent that works across multiple platforms and models, and you value the skill/memory ecosystem
• Build your own if you're deeply embedded in Claude Code already, want maximum control, and prefer to understand every piece of your system
• Hybrid approach — borrow Hermes's best ideas (identity layer, skill files) and implement them in whatever environment you're already productive in

"The real lesson isn't which tool to use — it's that the identity layer pattern is the future of personal AI, regardless of which runtime you build it on."