Hermes Agent Deep Dive 2026: Der selbstverbessernde KI-Agent, der sich wirklich an dich erinnert

Du hast Hermes Agent wahrscheinlich schon auf GitHub Trending gesehen – über 73.000 Sterne und es werden schnell mehr. Entwickelt von Nous Research (dem Labor hinter den Hermes- und Nomos-Modellfamilien), ist es ein Open-Source-KI-Agent, der auf deiner eigenen Hardware läuft. Kein Chatbot-Wrapper. Kein IDE-Plugin. Ein vollständig autonomer Agent mit Gedächtnis, Zeitplanung, Tool-Nutzung und einer Lernschleife, die umso besser wird, je länger er läuft.

Das hier ist keine Zusammenfassung einer Pressemitteilung. Das ist ein praxisorientierter Deep Dive: was Hermes tatsächlich tut, wie du es einrichtest, was gut funktioniert, was nicht und ob es deine Zeit wert ist. Jedes hier beschriebene Feature wird mit einem realen Anwendungsszenario vorgestellt, das du heute noch ausprobieren kannst.

Was Hermes Agent tatsächlich ist

Hermes Agent ist ein selbst gehosteter KI-Agent, der auf deinem Server (oder Laptop oder einem 5-Dollar-VPS) lebt und über ein Terminal, Telegram, Discord, Slack, WhatsApp, Signal – über 15 Plattformen von einem einzigen Gateway-Prozess aus – mit dir spricht. Er verwendet jedes LLM, auf das du ihn verweist: OpenAI, Anthropic, DeepSeek, Nous Portal, OpenRouter mit über 200 Modellen oder deinen eigenen lokalen Endpoint.

Das Alleinstellungsmerkmal, das ihn von „nur einem weiteren Agent-Framework“ unterscheidet: er hat eine geschlossene Lernschleife (closed learning loop). Er merkt sich Dinge über Sitzungen hinweg, erstellt wiederverwendbare Skills aus komplexen Aufgaben, verbessert diese Skills während der Nutzung und baut mit der Zeit ein Profil von dir auf. Die meisten Agenten beginnen bei jeder Konversation von vorne. Hermes sammelt Kontext.

Er ist MIT-lizenziert, was wichtig ist, wenn du darauf aufbauen willst.

Schlüsselzahlen:

73.600+ GitHub Sterne (Stand: April 2026)
647 Skills in 4 Registries (79 integriert, 47 optional, 521 von der Community beigesteuert)
15+ Messaging-Plattformen von einem Gateway aus unterstützt
6 Terminal-Backends: local, Docker, SSH, Daytona, Singularity, Modal
Minimale Kontextanforderung: 64K Tokens (Modelle darunter werden beim Start abgewiesen)

Installation: 60 Sekunden, kein Witz

# Einzeilige Installation — Linux, macOS, WSL2, sogar Android via Termux
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

# Lade deine Shell neu
source ~/.bashrc  # oder: source ~/.zshrc

# Beginne zu chatten
hermes

Der Installer kümmert sich um alles: Python 3.11 (über uv, ohne sudo), Node.js v22, ripgrep, ffmpeg. Die einzige Voraussetzung ist git.

Nach der Installation erhältst du eine Reihe von CLI-Befehlen, die die meisten Konfigurationen abdecken:

hermes model    # Wähle deinen LLM-Anbieter interaktiv aus
hermes tools    # Aktiviere/deaktiviere Tool-Gruppen
hermes setup    # Vollständiger Einrichtungsassistent (erledigt alles auf einmal)
hermes gateway  # Starte das Messaging-Gateway
hermes doctor   # Diagnostiziere Probleme
hermes update   # Aktualisiere auf die neueste Version

Funktioniert auch auf Android. Termux bekommt einen dedizierten Installationspfad mit einem kuratierten .[termux]-Extra, das Android-inkompatible Voice-Abhängigkeiten überspringt. Du kannst buchstäblich einen KI-Agenten von deinem Handy aus betreiben.

Auswahl eines Modell-Anbieters

Hermes zwingt dich nicht zu einem bestimmten Anbieter. Führe hermes model aus und wähle aus der Liste:

Anbieter	Was es ist	Auth-Methode
Nous Portal	Abonnement, Zero-Config	OAuth Login
OpenAI Codex	ChatGPT OAuth, Codex Modelle	Device Code Auth
Anthropic	Claude-Modelle direkt	Claude Code Auth oder API Key
OpenRouter	200+ Modelle, Multi-Provider	API Key
DeepSeek	Direkte API	API Key
GitHub Copilot	GPT-5.x, Claude, Gemini via Copilot	OAuth
Hugging Face	20+ offene Modelle	HF_TOKEN
Custom Endpoint	VLLM, SGLang, Ollama, jeder OpenAI-kompatible	Base URL + Key

Plus: Z.AI/GLM, Kimi/Moonshot, MiniMax, Alibaba Cloud/DashScope, Arcee AI und mehr.

Die 64K-Regel: Hermes benötigt mindestens 64.000 Tokens an Kontext. Modelle mit weniger werden beim Start abgewiesen. Das macht Sinn – mehrstufige Tool-Calling-Workflows fressen Kontext schnell auf, und ein kleines Fenster bedeutet, dass der Agent mitten in einer Aufgabe den Faden verliert. Wenn du ein lokales Modell betreibst, setze --ctx-size 65536 oder höher.

Wechsle den Anbieter jederzeit mit hermes model. Keine Code-Änderungen, kein Lock-in.

Das Gedächtnissystem: Klein, begrenzt und bewusst

Hier unterscheidet sich Hermes von den meisten Agent-Frameworks. Anstatt alles in eine Vektordatenbank zu kippen, verwendet Hermes zwei winzige, zeichenbegrenzte Dateien:

Datei	Zweck	Limit
`MEMORY.md`	Notizen des Agenten – Fakten zur Umgebung, Konventionen, gelernte Lektionen	2.200 Zeichen (~800 Tokens)
`USER.md`	Benutzerprofil – deine Vorlieben, Kommunikationsstil	1.375 Zeichen (~500 Tokens)

Beide liegen in ~/.hermes/memories/ und werden zu Beginn der Sitzung als Frozen Snapshot in den System Prompt injiziert.

Wie das Gedächtnis in der Praxis tatsächlich funktioniert:

══════════════════════════════════════════════
MEMORY (your personal notes) [67% — 1,474/2,200 chars]
══════════════════════════════════════════════
User's project is a Rust web service at ~/code/myapi using Axum + SQLx
§This machine runs Ubuntu 22.04, has Docker and Podman installed
§User prefers concise responses, dislikes verbose explanations

Der Agent verwaltet sein eigenes Gedächtnis durch drei Aktionen:

add – Einen neuen Fakt speichern
replace – Einen bestehenden Eintrag aktualisieren (Substring-Matching)
remove – Etwas löschen, das nicht mehr relevant ist

Der Haken an der Sache mit dem Frozen Snapshot: Wenn Hermes während einer Sitzung ins Gedächtnis schreibt, werden die Änderungen sofort auf die Festplatte geschrieben – aber sie erscheinen erst in der nächsten Sitzung im System Prompt. Das ist beabsichtigt (erhält den LLM-Prefix-Cache für die Performance), bedeutet aber, dass der Agent etwas „vergessen“ könnte, das er gerade gelernt hat, wenn du in derselben Sitzung weiterredest.

Wenn das Gedächtnis voll ist, erhält der Agent einen Fehler mit den aktuellen Einträgen und Nutzungsstatistiken und muss dann Einträge zusammenfassen oder ersetzen, um Platz zu schaffen. Es ist wie bei einem Menschen mit einem Notizbuch, das nur 15 Zeilen hat – man lernt, wählerisch zu sein, was man aufschreibt.

Was man speichern und was man weglassen sollte:

✅ Speichern: Benutzervorlieben, Umgebungsfakten, Projektkonventionen, Korrekturen, Workflow-Muster
❌ Weglassen: Triviale Informationen, leicht durchsuchebare Fakten, große Codeblöcke, sitzungsspezifische temporäre Daten

Dieser begrenzte Ansatz ist erfrischend. Die meisten Gedächtnissysteme von Agenten haben entweder keine Grenzen (und füllen sich mit Rauschen) oder verwenden Vektor-Retrieval (was Relevanz halluziniert). Hermes erzwingt Disziplin.

Skills: Prozedurales Gedächtnis, das der Agent selbst erstellt

Skills sind die Antwort von Hermes auf die Frage: „Wie wird man bei wiederkehrenden Aufgaben besser?“ Wenn der Agent etwas Komplexes abschließt, kann er einen Skill erstellen – im Wesentlichen eine SKILL.md-Datei mit Anweisungen für das nächste Mal. Skills verbessern sich während der Nutzung von selbst.

Das Ökosystem ist überraschend groß: 647 Skills in 4 Registries. Die integrierten decken ab:

Coding Agents: Claude Code, Codex, OpenCode Delegation
Kreativ-Tools: ASCII-Art, p5.js generative Kunst, Manim-Mathe-Animationen, Excalidraw-Diagramme, Architekturdiagramme
Plattform-Integrationen: Apple Notes, Apple Reminders, FindMy, iMessage
Spaßiges Zeug: Minecraft Modpack Server-Setup, Pokemon-Spieler (ja, er spielt autonom Pokemon per Headless Emulation)
Design: 54 produktionsreife Design-System-Templates, extrahiert aus echten Websites (Stripe, Linear, Vercel, Notion, Airbnb…)

Skills folgen dem offenen Standard agentskills.io, sind also portabel und können von der Community geteilt werden.

Reales Szenario: Du bittest Hermes, einen Docker Compose Stack für eine Postgres + Redis + Node App einzurichten. Er tut es und erstellt dann einen Skill namens „docker-compose-setup“ mit dem Template, häufigen Fallstricken und Port-Konventionen, die er dabei entdeckt hat. Wenn du das nächste Mal nach einem ähnlichen Stack fragst, lädt er den Skill und erledigt es in der Hälfte der Schritte.

Tools: 47 integrierte, nach Kategorien geordnet

Hermes wird mit einer breiten Tool Registry ausgeliefert. Du aktivierst/deaktivierst Gruppen mit hermes tools:

Kategorie	Beispiele	Wofür
Web	`web_search`, `web_extract`	Das Web durchsuchen und scrapen
Terminal & Files	`terminal`, `process`, `read_file`, `patch`	Befehle ausführen, Dateien bearbeiten
Browser	`browser_navigate`, `browser_snapshot`, `browser_vision`	Vollständige Browser-Automatisierung
Media	`vision_analyze`, `image_generate`, `text_to_speech`	Bildanalyse, -erzeugung, TTS
Agent orchestration	`todo`, `execute_code`, `delegate_task`	Planung, Subagents, Code-Ausführung
Memory & recall	`memory`, `session_search`	Persistentes Gedächtnis, sitzungsübergreifende Suche
Automation	`cronjob`, `send_message`	Geplante Aufgaben, ausgehende Nachrichten

Schnelles Aktivieren/Deaktivieren:

# Nur mit Web- und Terminal-Tools starten
hermes chat --toolsets "web,terminal"

# Oder interaktiv konfigurieren
hermes tools

Terminal-Backends: Überall sicher ausführen

Dies ist eines der stärksten praktischen Features von Hermes. Du kannst wählen, wo die Terminalbefehle des Agenten tatsächlich ausgeführt werden:

Backend	Anwendungsfall
`local`	Standard – läuft auf deiner Maschine
`docker`	Isolierte Container – sicher für nicht vertrauenswürdige Aufgaben
`ssh`	Remote-Server – Agent kann seinen eigenen Code nicht anrühren
`daytona`	Cloud-Sandbox – persistent, schläft bei Inaktivität
`modal`	Serverless – skaliert, Pay-per-Use
`singularity`	HPC-Container – Rootless Cluster-Computing

# ~/.hermes/config.yaml
terminal:
  backend: docker
  docker_image: python:3.11-slim
  container_persistent: true  # Pakete überleben Sitzungen hinweg
  container_cpu: 1
  container_memory: 5120      # 5GB

Das SSH-Backend ist der sicherheitstechnische Sweet Spot: Der Agent arbeitet auf einer entfernten Maschine und kann buchstäblich seinen eigenen Code oder seine Konfiguration nicht ändern. Container-Backends (Docker, Singularity, Modal) fügen weitere Härtung hinzu: schreibgeschütztes Root-Dateisystem, alle Linux-Capabilities entfernt, keine Rechteausweitung, PID-Limits, vollständige Namespace-Isolierung.

Praktischer Tipp: Wenn du Hermes auf einem VPS betreibst und ihm echte Aufgaben gibst, beginne mit dem docker-Backend. Wenn du den Aufgaben vertraust, aber eine Trennung wünschst, verwende ssh. Nutze local nur für die Entwicklung oder für Aufgaben, die du auch selbst ausführen würdest.

Cron: Integrierte geplante Automatisierung

Hermes hat einen eingebauten Cron-Scheduler. Keine externen Tools erforderlich. Erstelle Jobs in natürlicher Sprache oder mit Cron-Ausdrücken, und die Ergebnisse werden an jede beliebige Messaging-Plattform geliefert.

# Aus dem Chat heraus
/cron add "every 6h" "Check GitHub trending repos in Python and summarize the top 5 new ones. If nothing interesting, respond with [SILENT]." --name "GitHub watcher" --deliver telegram

# Von der CLI aus
hermes cron create "0 9 * * 1" \
  "Generate a weekly report of top AI news, trending ML repos, and most-discussed HN posts." \
  --name "Weekly AI digest" \
  --deliver telegram

Das Wichtigste, was du verstehen musst: Cron-Jobs laufen in frischen Agenten-Sitzungen ohne Erinnerung an deinen aktuellen Chat. Prompts müssen vollständig in sich abgeschlossen sein. Das bringt Leute durcheinander – sie schreiben einen Cron-Prompt wie „mach das, was wir besprochen haben“ und wundern sich, warum der Agent keine Ahnung hat, was sie meinen.

Der --script-Parameter ist der eigentliche Power-Move. Du kannst ein Python-Skript anhängen, das vor jeder Ausführung läuft. Sein stdout wird zum Kontext für den Agenten:

# ~/.hermes/scripts/watch-site.py
import hashlib, json, os, urllib.request

URL = "https://example.com/pricing"
STATE_FILE = os.path.expanduser("~/.hermes/scripts/.watch-state.json")

content = urllib.request.urlopen(URL, timeout=30).read().decode()
current_hash = hashlib.sha256(content.encode()).hexdigest()

# Lade vorherigen Zustand
prev_hash = None
if os.path.exists(STATE_FILE):
    with open(STATE_FILE) as f:
        prev_hash = json.load(f).get("hash")

# Speichere aktuellen Zustand
with open(STATE_FILE, "w") as f:
    json.dump({"hash": current_hash, "url": URL}, f)

if prev_hash and prev_hash != current_hash:
    print(f"CHANGE DETECTED on {URL}")
    print(f"Content preview:\n{content[:2000]}")
else:
    print("NO_CHANGE")

/cron add "every 1h" "If script says CHANGE DETECTED, summarize what changed. If NO_CHANGE, respond with [SILENT]." --script ~/.hermes/scripts/watch-site.py --name "Pricing monitor" --deliver telegram

Der [SILENT]-Trick: Wenn die Antwort des Agenten [SILENT] enthält, wird die Zustellung unterdrückt. Du wirst nur benachrichtigt, wenn tatsächlich etwas passiert. Kein Spam.

Messaging-Gateway: Sprich mit ihm von deinem Handy aus

hermes gateway setup  # Interaktiv – wählt deine Plattform
hermes gateway        # Startet den Gateway-Prozess

Hermes unterstützt über 15 Messaging-Plattformen von einem Gateway aus: Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Mattermost, E-Mail, SMS, DingTalk, Feishu, WeCom, BlueBubbles, Home Assistant und Open WebUI.

Beispiel für die Telegram-Einrichtung (die häufigste):

Erstelle einen Bot über @BotFather (/newbot)
Hol dir deine User-ID über @userinfobot
Führe hermes gateway setup aus, wähle Telegram, füge Token und User-ID ein
Starte das Gateway: hermes gateway

Das ist alles. Jetzt kannst du mit deinem Agenten von deinem Handy aus chatten, während er auf deinem Server arbeitet.

Sprachnotizen funktionieren auch – sende eine Sprachnachricht auf Telegram, Hermes transkribiert sie automatisch mit faster-whisper (läuft lokal, kostenlos) und antwortet auf den Text.

Gruppenchat-Tipp: Telegram-Bots haben standardmäßig den Privacy Mode aktiviert – der Bot sieht nur /commands und direkte Antworten. Damit er alle Nachrichten in einer Gruppe sehen kann, deaktiviere entweder den Privacy Mode im BotFather oder befördere den Bot zum Admin.

MCP-Integration: Mit externen Tools erweitern

Hermes unterstützt das Model Context Protocol (MCP) – verbinde dich mit einem beliebigen MCP-Server, um Tools hinzuzufügen:

# ~/.hermes/config.yaml
mcp:
  servers:
    - name: "github"
      command: "npx"
      args: ["-y", "@modelcontextprotocol/server-github"]
      env:
        GITHUB_TOKEN: "your-token"

MCP-Tools erscheinen neben den integrierten Tools. Du kannst filtern, welche MCP-Tools der Agent verwenden darf, um eine Überladung mit Tools zu vermeiden.

Sicherheit: Sieben Schichten tief

Hermes hat ein echtes Defense-in-Depth-Modell, nicht nur „wir haben einen Approval Prompt hinzugefügt“:

User authorization – Allowlists steuern, wer mit dem Agenten sprechen darf
Dangerous command approval – Human-in-the-Loop für destruktive Operationen (rm -rf, chmod 777, etc.)
Container isolation – Docker/Singularity/Modal mit gehärteten Einstellungen
MCP credential filtering – env var-Isolierung für MCP-Subprozesse
Context file scanning – Erkennung von Prompt Injection in Projektdateien
Cross-session isolation – Sitzungen können nicht auf die Daten der anderen zugreifen
Input sanitization – Parameter für das Arbeitsverzeichnis werden gegen eine Allowlist validiert

Approval-Modi:

# ~/.hermes/config.yaml
approvals:
  mode: manual   # manual | smart | off
  timeout: 60    # Sekunden bis zur automatischen Ablehnung

manual (Standard): Fragt immer vor gefährlichen Befehlen
smart: Verwendet ein Hilfs-LLM zur Risikobewertung – genehmigt automatisch risikoarme, lehnt gefährliche automatisch ab, eskaliert unsichere Fälle
off / --yolo: Umgeht alle Prüfungen. Nur in CI/CD oder Wegwerf-Containern verwenden.

Der Timeout ist Fail-Closed: Wenn du nicht innerhalb von 60 Sekunden antwortest, wird der Befehl abgelehnt. Nicht genehmigt. Das ist die richtige Standardeinstellung.

Subagents: Delegieren und parallelisieren

Hermes kann isolierte Subagents für parallele Arbeitsströme spawnen:

❯ Recherchiere diese drei Themen gleichzeitig:
  1. Neueste Benchmarks für Rust Async Runtimes
  2. Neue Features von PostgreSQL 17
  3. Best Practices für LLM-Caching in der Produktion

Jeder Subagent erhält seine eigene Sitzung, eigene Tools und eigenen Kontext. Die Ergebnisse kommen zum übergeordneten Agenten zurück. Dies ist nützlich für Aufgaben, die von Natur aus parallel sind – Recherche, Stapelverarbeitung, Operationen über mehrere Repos.

Du kannst auch execute_code verwenden, um Python-Skripte zu schreiben, die Tools per RPC aufrufen und so mehrstufige Pipelines zu Turns ohne Kontextkosten zusammenfassen.

Echte Nachteile (Der ehrliche Teil)

Jede Review, die nur Gutes berichtet, ist nutzlos. Hier ist, was wirklich weh tut:

1. Das Gedächtnis ist winzig und erfordert aktive Verwaltung

2.200 Zeichen für das Agenten-Gedächtnis. 1.375 für das Benutzerprofil. Das sind insgesamt etwa 20 kurze Einträge. Für einen persönlichen Assistenten, der „mit dir wachsen“ soll, ist das Erreichen der Obergrenze frustrierend schnell. Du wirst feststellen, dass der Agent Runden damit verbringt, Gedächtniseinträge zu konsolidieren und zu ersetzen, anstatt tatsächliche Arbeit zu leisten. Der begrenzte Ansatz ist philosophisch solide, aber in der Praxis bedeutet es, dass der Agent Dinge vergisst, von denen du wünschtest, er hätte sie nicht vergessen.

2. Der Frozen Snapshot erzeugt einen „Gedächtnis-Lag”

Änderungen am Gedächtnis während einer Sitzung werden erst in der nächsten Sitzung wirksam. Das bedeutet, wenn du dem Agenten sagst „denk dran, ich bin auf PostgreSQL 17 umgestiegen“, schreibt er das zwar auf die Festplatte – aber wenn du später in derselben Konversation nach deinem Datenbank-Setup fragst, zeigt der System Prompt immer noch die alten Infos. Der Agent kann den Live-Zustand über Tool-Antworten überprüfen, aber er denkt nicht immer daran. Das führt zu verwirrenden Momenten, in denen der Agent vergessen zu haben scheint, was du ihm gerade gesagt hast.

3. Cron-Prompts müssen vollständig in sich abgeschlossen sein

Jeder Cron-Job läuft in einer leeren Sitzung. Kein Gedächtnis, keine Konversationshistorie, kein Kontext von früheren Läufen. Das bedeutet, deine Cron-Prompts müssen alles genau beschreiben – was zu tun ist, wie es zu tun ist, welches Ausgabeformat zu verwenden ist, wohin geliefert werden soll. Gute Cron-Prompts zu schreiben ist eine eigene Fähigkeit, und die ersten paar Versuche führen meist zu nutzlosen Ergebnissen, weil die Leute zu wenig spezifizieren.

4. Das 64K-Kontext-Minimum schließt kleinere lokale Modelle aus

Wenn du vollständig lokal mit einem 7B- oder 13B-Modell arbeiten möchtest, hast du wahrscheinlich Pech, es sei denn, du kannst dir den RAM für 64K Kontext leisten. Dies ist eine vernünftige technische Entscheidung (kleiner Kontext = kaputte Agenten-Schleifen), aber es bedeutet, dass Hermes nicht wirklich „auf allem läuft“ – er läuft auf allem, was ein 64K-Kontext-Modell bereitstellen kann.

5. Gateway-Neustart trennt Verbindungen

Wenn du das Gateway neu starten musst (Update, Konfigurationsänderung, Wiederherstellung nach Absturz), werden alle aktiven Messaging-Sitzungen getrennt. Es gibt keine reibungslose Übergabe. Benutzer auf Telegram/Discord sehen nur, wie der Bot verstummt und dann wieder auftaucht. Für den persönlichen Gebrauch ist das in Ordnung; für Team-Deployments ist es eine unschöne Kante.

Wo Hermes hingehört: 3 schnelle Vergleiche

Dies sind keine vollständigen Reviews – nur Positionierungshinweise, damit du weißt, wann du was wählen solltest.

Hermes vs OpenClaw: Beide sind selbst gehostete persönliche KI-Agenten mit Messaging-Gateway, Cron, Gedächtnis und Tool-Nutzung. OpenClaw ist Node.js-basiert mit einem Fokus auf Kanalvielfalt und Plugin-Architektur. Hermes ist Python-basiert mit einem Fokus auf die Lernschleife (Skills, Selbstverbesserung) und Forschungsbereitschaft (Trajectory Export, RL-Training). Wenn du „wachsende Agentenintelligenz“ willst, neige zu Hermes. Wenn du „stabiles Message-Routing über 15 Plattformen mit einem umfangreichen Plugin-Ökosystem“ willst, neige zu OpenClaw.

Hermes vs LangGraph: LangGraph ist ein Framework zum Erstellen von Agenten-Workflows – du schreibst den Graphen, definierst die Knoten, verwaltest den Zustand. Hermes ist ein einsatzbereiter Agent – installieren und chatten. Wenn du eine benutzerdefinierte Multi-Agenten-Orchestrierung für ein Produkt benötigst, verwende LangGraph. Wenn du einen persönlichen Agenten benötigst, der sofort funktioniert, verwende Hermes.

Hermes vs CrewAI: CrewAI konzentriert sich auf Multi-Agenten-Rollenspiele (Agenten wie „Forscher“, „Autor“, „Redakteur“, die zusammenarbeiten). Hermes ist ein einzelner Agent mit Subagent-Delegation. CrewAI ist besser für vordefinierte Team-Workflows. Hermes ist besser für offene persönliche Assistenz, bei der die Aufgabe nicht im Voraus bekannt ist.

Kurzanleitung / Cheat Sheet

Wichtige Befehle

hermes                    # Chatten starten
hermes model              # LLM-Anbieter wechseln
hermes tools              # Toolsets aktivieren/deaktivieren
hermes gateway setup      # Messaging-Plattformen konfigurieren
hermes gateway            # Messaging-Gateway starten
hermes cron list          # Geplante Jobs auflisten
hermes config set KEY VAL # Einen Konfigurationswert setzen
hermes doctor             # Probleme diagnostizieren
hermes update             # Auf die neueste Version aktualisieren
hermes --continue         # Letzte Sitzung fortsetzen
hermes --yolo             # Befehlsfreigabe umgehen (Vorsicht!)

Empfohlene Erstkonfiguration

# ~/.hermes/config.yaml

# Docker aus Sicherheitsgründen verwenden
terminal:
  backend: docker
  docker_image: python:3.11-slim
  container_persistent: true

# Freigabeaufforderungen aktiviert lassen
approvals:
  mode: manual
  timeout: 60

Häufige Fallstricke (Gotchas)

Problem	Ursache	Lösung
Agent ignoriert Gedächtnis, das du gerade hinzugefügt hast	Frozen Snapshot – Gedächtnis wird nur bei Sitzungsstart geladen	Starte eine neue Sitzung (`hermes`)
Cron-Job erzeugt nutzlose Ausgabe	Prompt ist nicht in sich abgeschlossen	Beschreibe alles genau im Cron-Prompt
Bot sieht keine Gruppennachrichten	Telegram Privacy Mode	In BotFather deaktivieren, dann Bot erneut zur Gruppe hinzufügen
Modell wird beim Start abgewiesen	Kontextfenster < 64K	Verwende ein größeres Modell oder erhöhe `--ctx-size`
`hermes: command not found` nach der Installation	Shell nicht neu geladen	Führe `source ~/.bashrc` aus

Fazit

Hermes Agent ist der vollständigste Open-Source-KI-Agent für den persönlichen Gebrauch, der im April 2026 verfügbar ist. Die Lernschleife (Gedächtnis + Skills + Benutzermodellierung) ist wirklich neuartig – die meisten konkurrierenden Agenten versuchen nicht einmal eine sitzungsübergreifende Verbesserung. Die 6 Terminal-Backends geben dir echte Flexibilität bei der Bereitstellung. Das Ökosystem mit 647 Skills bedeutet, dass du nicht bei null anfängst.

Die Kompromisse sind real: winzige Gedächtnisgrenzen, der Lag durch den Frozen Snapshot, der Aufwand für Cron-Prompts und eine 64K-Kontext-Untergrenze. Aber das sind technische Entscheidungen, keine Fehler – sie halten das System begrenzt und vorhersagbar.

Wenn du einen KI-Agenten willst, der auf deinem Server lebt, über Telegram mit dir spricht, geplante Aufgaben ausführt und mit der Zeit tatsächlich besser wird – dann ist Hermes der, den du ausprobieren solltest. Die Installation dauert 60 Sekunden. Du wirst innerhalb einer Stunde wissen, ob er zu deinem Workflow passt.

Links:

GitHub: github.com/NousResearch/hermes-agent
Docs: hermes-agent.nousresearch.com/docs
Discord: discord.gg/NousResearch
Skills Hub: agentskills.io
Lizenz: MIT

Hermes Agent Review 2026: Der selbstverbessernde KI-Agent, der sich wirklich an dich erinnert