Hermes Agent: Zero to Personal AI Assistant (1 Hour Course)

Hermes Agent: Zero to Personal AI Assistant

Hermes Agent is a powerful, open-source AI agent designed to grow with its user through a self-improving loop and extensive skill set. It operates on personal infrastructure, offering a robust, private, and customizable AI assistant capable of handling complex workflows, scheduled automations, and intelligent interactions across various messaging platforms. Its core purpose is to transform reactive AI into a proactive, evolving digital assistant that streamlines tasks, manages information, and enhances productivity by continuously learning and adapting to user needs.

🔑 Core Pillars of Hermes Agent:

• Memory 🧠: This pillar ensures Hermes retains crucial context across sessions. It comprises:
  • user.md: Stores personal information, preferences, and style.
  • memory.md: Contains environmental details, project context, and business information.
  • These files are loaded at session start, mitigating the "stateless" nature of AI by providing immediate context. Hermes automatically extracts and updates these files based on interactions, though user prompts like "chuck that in the memory" aid in refinement.
  • Beginner Nuance: Durable preferences are saved to memory, session search utilizes a SQLite database for past conversations, and secrets or temporary task statuses should not be stored here.
• Skills 🛠️: Represent procedural memory, acting as reusable playbooks for executing tasks efficiently and consistently.
  • Skills are defined in skill.md files with a YAML front matter, enabling "progressive disclosure" – only loading relevant skill context when needed.
  • Hermes can autonomously create and update skills by analyzing workflows and user feedback, ensuring continuous improvement.
  • A vast Skills Hub offers over 520 community-contributed skills and official Anthropic skills for easy integration.
• Soul 💖: Shapes the assistant's personality and tone, contained within a markdown file.
  • Different Hermes agents can embody unique "vibes" (e.g., concise, sarcastic, direct), influencing how they interact and respond.
  • Like memory and skills, the Soul evolves based on ongoing feedback and interactions.
• Crons ⏰: Elevate Hermes from a reactive chatbot to a proactive, scheduled automation engine.
  • Users can set up cron jobs using natural language (e.g., "every morning at 6 AM, do X, Y, and Z").
  • When a cron triggers, it invokes a fresh, isolated session, runs the specified skill, and delivers results back to the original chat, updating local files as needed.
  • Safety Nuance: Cron sessions cannot recursively create more cron jobs, requiring self-contained prompts.
• Self-Improving Loop 🔄: The fundamental mechanism for Hermes's growth.
  • This loop involves doing work, the agent learning from the experience, saving useful information to memory or agents.mmd, transforming repeatable steps into skills, and leveraging searchable history for past context.
  • Nuance: Automatic does not mean magic; user correction and explicit requests to save information or create/update skills are vital for optimal improvement.
• Context File (agents.mmd / claw.md): An honorable mention for project-specific goals and structures, primarily used for coding projects and terminal interactions, offering local context distinct from global memory or soul files.

🆚 Comparison with Other AI Agents & Interfaces:

• Hermes vs. Claude Code & OpenClaw:
  • Claude Code remains a "daily driver" for 90% of knowledge and coding work, typically used at a desk for direct, driven interaction.
  • OpenClaw and Hermes are better suited for "on-the-go" usage, enabling quick cron setups and mobile interactions via platforms like Telegram.
  • Hermes is lighter, faster, and emphasizes self-improvement, often more stable than OpenClaw, which has a larger team but more frequent updates that can sometimes break setups.
  • All these agents can be used complementarily, especially by syncing project knowledge (skills, business context) to GitHub repos, allowing different agents to interact with the same codebase regardless of specific terminology. Claude Code can even manage multiple Hermes and OpenClaw agents, maintaining organization.
• Terminal (CLI) vs. Telegram (Messaging Platforms):
  • CLI is the "cockpit" for deep work, coding, and comprehensive project management, offering full control, better context visibility, and access to all slash commands.
  • Telegram (or Discord, Slack, WhatsApp, iMessage) acts as a "remote control" for scheduled tasks, quick requests, and general knowledge work that isn't high-risk. While the agent's core capabilities are the same, Telegram offers less visibility into the context window and session management, making it less ideal for "vibe coding" complex applications. The context window is token-based, not message-based, utilizing auto-compaction, which is less transparent in messaging interfaces.

⚙️ Setup & Onboarding Practical Steps:

1. VPS Hosting: Utilize a Virtual Private Server (VPS), such as Hostinger, which offers one-click Hermes Agent installation. Begin with a KVM 2 plan and consider an annual commitment for cost savings (code Nate Herk for 10% off).
2. Installation Method: Choose between installing Hermes directly at the root of the VPS or within a Docker container. The Docker approach is recommended for isolating different Hermes agents with their own memory, tools, and private keys.
3. Manage Agents with Claude Code: A best practice is to create a dedicated Claude Code project to manage all VPS agents, storing IP addresses, root passwords, environment variables, and security notes. This ensures organization, facilitates recovery from issues, and helps with security configurations.
4. Initial Configuration:
   • Access the Hermes container via its IP address and login with the default admin username/password (save these securely, ideally in a Claude Code managed .env file).
   • Select OpenAI Codex as the inference provider, connecting via your ChatGPT subscription URL and a 9-digit code for authentication.
   • Choose a model (e.g., GPT 5.5).
   • Set up a messaging channel, typically Telegram, by creating a new bot via BotFather to obtain a bot token, and whitelisting your user ID using the userinfobot.
5. API Key Management: Never drop API keys directly into the chat. Instead, use the Hermes config set command in the VPS terminal to save keys securely into the /opt/data.env file within the Docker container. This ensures keys are not exposed in conversation history and supports the "least privilege rule" for security.
6. GitHub Integration:
   • Crucially, connect Hermes to a private GitHub repository for automated daily backups of all agent-related files, memory, and skills. This acts as a disaster recovery mechanism.
   • Hermes can research and set up the repo, requiring your GitHub username, desired repo name, commit identity, and a Personal Access Token (PAT) with appropriate scopes (e.g., repo permissions for read/write access).
   • The PAT should also be stored securely using Hermes config set, potentially requiring deletion/regeneration of tokens if permissions are initially incorrect.
   • Once configured, create a skill and a cron job (e.g., "every night at 12 AM Central Time, push changes to this GitHub repo") to automate backups.

💡 Best Practices for Effective Use & Maintenance:

• Effective Use:
  • Natural Language Interaction: Ask Hermes questions, provide links (e.g., X posts), and delegate tasks with natural language; it can research, plan, and execute.
  • Continuous Feedback: Engage in constant dialogue. If Hermes makes an error, correct it immediately and instruct it to update relevant skills or memory.
  • Skill Creation: When performing a task repeatedly, ask Hermes to create a skill for it to ensure consistency and efficiency.
• Maintenance:
  • Soul Editing: Adjust the soul file if the agent's tone or verbosity is off.
  • Cron Management: Easily create new scheduled tasks by describing them in natural language.
  • Troubleshooting: If something breaks, check memory.mmd first, as stale memory is a common cause of erratic behavior.
  • Auditing: Regularly ask Hermes to read its own memory and soul files to understand its current state and context.
• Security:
  • Dedicated Accounts: Provide Hermes agents with their own email addresses or accounts, rather than personal ones.
  • Granular API Keys: Use named API keys for each agent and service (e.g., OpenRouter, Perplexity) to monitor usage and costs.
  • Least Privilege Principle: Grant agents only the minimum necessary credentials and tools for their specific jobs.
  • Firewall Setup: Configure a firewall on your VPS to restrict access (e.g., to specific IPs, block ports). Hermes and Claude Code can assist in researching and implementing these security measures, even conducting security audits.
• Scaling with Multiple Hermes Agents:
  • Containerization: If running multiple agents on one VPS, use separate Docker containers for each to ensure independent memory, tools, and API keys. This prevents clashes and provides clearer visibility into individual agent activity and costs.
  • Decision Tree for New Agents: Create a new Hermes agent when a task or role requires:
    • Different permissions, secrets, or tools.
    • Separate, longer-term memory.
    • Ongoing, repeated work.
  • Avoid "One Mega Agent": A single agent with all keys and skills can lead to high confusion, context bloat, and increased risk. Segmenting agents by function (e.g., marketing, finance) lowers risk, improves debugging, and enhances visibility.
  • Start Simple: Begin with one main personal Hermes agent, mastering its use before scaling. Tools, crons, and skills can be easily migrated to new, specialized agents as needed.
  • Dashboard: Hermes offers a built-in dashboard for monitoring sessions, connected platforms, and crons, though CLI or Telegram is often preferred for on-the-go management. Accessing it requires opening a tunnel to the VPS.

Final Takeaway: Hermes Agent is not merely a tool to set up and forget; it is a dynamic teammate requiring continuous training and feedback. By diligently managing its memory, skills, and soul, and adhering to best practices for setup, security, and scaling, users can cultivate a highly personalized, proactive, and resilient AI assistant that significantly enhances their digital workflow and productivity. The journey involves both understanding the underlying mechanisms and effectively communicating with the agent to facilitate its learning and adaptation.