Video summary

100 hours of Hermes Agent lessons in 46 minutes

Main summary

Key takeaways

Technology

Tech Concepts & Product Features Covered (7-Level Hermes Agent Setup)

Overview / Positioning

  • The speaker presents Hermes Agent as an AI agent you can run on your own machine via a VPS, then progressively enhance.
  • The focus is practical, delivered as a step-by-step tutorial across seven levels.

Level 1 — Fundamentals: Self-Host on a VPS

  • Install Hermes Agent on a dedicated VPS.
  • Use the official GitHub repo quick-install (designed for a one-command dependency install).
  • Deployment recommendation:
    • Hostinger VPS
  • Key idea:
    • Run independently on the VPS.
    • Use different model providers for inference.

Choose an Inference Provider

During setup, select an inference provider. Options mentioned:

  • News portal
  • OpenRouter
  • LM Studio (local)
  • OpenAI Codex (via ChatGPT subscription)

Example: Using OpenRouter

  • Create an OpenRouter account and an API key.
  • Select a model (example used: “Claude Opus 4.7”).
  • Verify the gateway:
    • Launch “Hermes chat” on the VPS.
    • Confirm it responds.

Key Tutorial Mechanics

  • Create the VPS via Hostinger (noted coupon usage)
  • SSH access to the VPS
  • Root password reset instructions (if needed)
  • Hermes installation via GitHub quick install
  • Model/provider configuration using the API key

Level 2 — Discord Integration: Hermes as a Discord Bot

  • Set up a Hermes gateway that connects to Discord.
  • Use “Hermes gateway setup” and select Discord.
  • Create a Discord application:
    • Enable bot token
    • Enable privileged gateway intents, explicitly listing 3:
      • presence
      • server members
      • message content
    • Select bot permissions (e.g., send messages, embed links, read history, etc.)
    • Generate an OAuth invite URL and invite the bot to a server

Configure Hermes for Discord

  • Provide the Discord user ID:
    • Enable developer mode to copy it
  • Set the home channel (can be left empty)

Run and Verify

  • Run the Hermes gateway as a systemd service and start it.
  • Verify by:
    • Tagging the bot
    • Sending prompts like “Who are you?”
    • Checking response markers:
      • 👀 / eyes = message received
      • ✅ / check = response completed

Level 3 — Hermes Curator: Compact Skills to Save Tokens

  • Add Hermes Curator to prevent “skills stacking” and reduce wasted context/tokens.
  • Deletion policy to avoid “context rot”:
    • Skills unused for 30 days become stale
    • Skills unused for 90 days are deleted
  • Steps included:
    • Update Hermes to the latest version
    • Check curator status and confirm default behavior is enabled
  • Claimed benefit:
    • Less irrelevant context → lower token spend

Level 4 — Automations (cron): Scheduled Backups to GitHub

  • Introduce cron jobs / scheduled tasks inside Hermes Agent.
  • Core use case shown:
    • Daily backups of the entire .hermes folder to a private GitHub repo

GitHub Configuration

  • Create a private repository
  • Create a fine-grained personal access token scoped to that repo
  • Token permissions:
    • read and write (to push daily backups)

VPS Configuration

  • Store the token as an environment variable using Hermes config into .env
    • Example concept: hermes config set ... into .env
  • Validate Hermes can see and use it

Cron Creation

  • In plain English, instruct Hermes to create a daily 3:00 a.m. backup
  • Ensure gateway status is maintained (systemd keeps running)
  • Run a test to confirm a commit/push succeeded

Notes

  • Backups can exceed GitHub limits (example mentioned ~60MB)
    • Suggestion: optimize by backing up skills only instead of everything
  • Plain-English prompts can also customize what gets backed up

Level 5 — Kanban Dashboard for Multi-Agent Orchestration

  • Major release described: a built-in Kanban board for managing multiple AI agents in parallel.
  • Key behavior:
    • Agents claim tasks from Kanban columns/stages and work simultaneously
    • The human gains visual observability (instead of monitoring many terminals)

Setup Workflow

  • Hermes can self-install the Kanban/multi-agent dashboard by browsing release info and completing steps.
  • Requires “specialist profiles” (roles such as researcher/writer/reviewer).

Model Guidance

  • Don’t use cheap models for orchestration.
  • Example recommendations:
    • Opus 4.7 and higher-end options (e.g., “GPT 5.5”)

Demonstrations

  • Run a local web UI on the VPS and view via an SSH tunnel
  • Trello-style drag-and-drop task management
  • Example content pipeline: “uncensored AI models”
    • Researcher agents find:
      • what’s new
      • what’s on YouTube
    • Analyst identifies gaps/angles
    • Writer drafts concepts
    • Shows Kanban states and task metadata (worker logs, dependencies, etc.)

Additional Monitoring (Beyond Kanban)

  • Discord/CLI visibility
  • Cron automations list
  • Logs
  • Available models
  • Token spend analytics
  • Ability to restart/update the gateway

Level 6 — “Holographic” Memory for Near-Infinite Long-Term Context

Problem Addressed

  • Agents lose context over time.
  • Beginners often fail to save facts correctly.
  • Why “more context” isn’t true memory:
    • More tokens = more cost and weaker attention
    • RAG/embeddings can be vague for structured facts (responsibilities/ownership)
    • Embeddings can cost money and may leak data
    • Summaries can blur precise facts

Level 6 Solution: Hermes Memory Setup

  • “Hermes memory setup” with multiple memory plugins, highlighting Holographic.
  • Claimed properties of holographic:
    • Fully local (no cloud data leakage)
    • No API keys required
    • Uses a local SQL database path

Configuration Options Mentioned

  • Auto-extract facts at session end (enable for maximum memory)
  • Trust score for new facts (default ~0.4)

Demonstration: Seeding Memory

  • Read previous sessions and seed memory.
  • Save key user preferences (example includes concise response preference).

Use Cases Listed

  • Remember key facts for each video/post (angles, sponsors, deadlines, what went wrong)
  • Track sponsor history automatically
  • Recall VPS setup/config details
  • Weekly VPS health checks (proactive cron)
  • Detect contradictions and request resolution
  • Find connections between past work topics

Level 7 — Expose Hermes as an MCP Backend (Interoperability)

  • Turn Hermes Agent into an MCP server (Model Context Protocol).
  • Purpose:
    • Let other tools/agents (e.g., Cloud Code, Claude Code) interact with Hermes as a backend

Three Main Use Cases

  1. Remote approval gate for risky/destructive actions
    • Hermes can pause and request approval via messaging platforms (e.g., Discord/Telegram/phone notifications)
  2. Walk-away mode
    • Hermes continues and sends progress pings; user responds from phone
  3. Tool-based collaboration
    • Claude Code fetches structured info from Hermes via MCP tools (e.g., read conversations/channels)

Testing Flow Shown

  • Prompt Hermes: “expose your Hermes to Claude Code via MCP”
  • Install and log in to Claude Code on the VPS
  • Register MCP in Claude Code using Hermes-provided commands
  • Verify MCP tools appear and can be called
  • Demonstrate tool calls returning Discord conversation/thread data and messages

Example MCP-Based Analysis

  • Claude Code uses Hermes MCP data to infer user attributes/goals, such as:
    • content creation
    • delegating
    • low verbosity tolerance
    • desire to automate and build AI agent workflows

Validated Benefit

  • Claude Code doesn’t need full Hermes context.
  • It can fetch context privately from Hermes via MCP.

Review / Guide / Tutorial Emphasis

  • The entire video is structured as a guided setup tutorial with progressive “levels” (1 → 7).
  • Repeated practical configuration steps include:
    • VPS + SSH
    • GitHub private repo + fine-grained token + env vars
    • Discord bot token + gateway intents + OAuth invite
    • Cron scheduling via plain-English instructions
    • Kanban orchestration with multi-agent pipelines
    • Holographic local memory seeding and retrieval
    • MCP server exposure and MCP tool testing from Claude Code

Main Speakers / Sources

  • Speaker: David Andre (only explicitly named speaker/source in the subtitles)

Primary External Sources Referenced

  • Hermes Agent GitHub repository
    • Quick install command referenced
    • “133,000 stars” mentioned
  • Hostinger
    • VPS deployment and sponsorship
  • OpenRouter
    • Inference provider and API keys
  • Discord Developer Portal
    • Bot app token, intents, OAuth setup
  • GitHub
    • Private repo + fine-grained personal access token
  • Model Context Protocol (MCP)
    • Referenced as defined by Anthropic; used by Claude Code

Original video