Hermes: Der KI-Mitarbeiter, der mit Ihnen wächst

Hermes: Der KI-Mitarbeiter, der mit Ihnen wächst

OpenClaw ist ein Agent, der Ihren Computer nutzen kann. Hermes ist ein KI-Mitarbeiter, der mit Ihnen wächst. Der Unterschied liegt in einem automatischen Selbstoptimierungszyklus, der Prozesse als wiederverwendbare Skills speichert.

Hermes Agent https://github.com/NousResearch/hermes-agent ist das Open-Source-Agenten-Framework von Nous Research https://nousresearch.com/ — ein Zweitplatzierter in derselben Kategorie wie Claude Code und Codex, der jedoch „mit der Nutzungsdauer besser wird“ als primäres Designziel und nicht als Nebeneffekt behandelt. Er läuft im Terminal, als native Desktop-App, in Messaging-Plattformen (Telegram, Discord, Slack, WhatsApp, Signal, iMessage, Teams, E-Mail und mehr) sowie in IDEs — alles ausgehend von demselben Agentenkern. Er ist providerunabhängig — Modelle und Anbieter lassen sich mitten im Workflow austauschen — und lernt über Sitzungen hinweg durch zwei verknüpfte Mechanismen: persistenter Speicher und wiederverwendbare Skills.

Quelle: Hermes Agent repo (Nous Research) https://github.com/NousResearch/hermes-agent · Hermes Agent docs https://hermes-agent.nousresearch.com/docs/ · Nous Research https://nousresearch.com/

Der Selbstoptimierungszyklus

Was Hermes wie einen Mitarbeiter und nicht wie ein Werkzeug wirken lässt, ist der Selbstoptimierungszyklus , der im Hintergrund jeder Unterhaltung läuft. Nach jedem Durchgang analysiert eine Hintergrundprüfung die Konversation und speichert das Gelernte leise ab — eine dauerhafte Information im Gedächtnis oder eine wiederverwendbare Prozedur als Skill. Oft erscheint danach eine stille 💾 Memory updated -Zeile im Chat.

Diese Prüfung läuft nicht bei jedem einzelnen Durchgang; sie wird durch einen Zähler ausgelöst. Hermes startet eine Gedächtnis- und Skill-Prüfung standardmäßig etwa alle ~10 Durchgänge (_memory_nudge_interval = 10, _skill_nudge_interval = 10), wobei beide Werte konfigurierbar sind (nudge_interval, creation_nudge_interval). Wenn der Zähler auslöst, startet er einen Hintergrund-Fork des Agenten in einem eigenen Kontext, der das Gespräch ausliest und dauerhafte Lehren zurückschreibt.

• Memory speichert kleine, dauerhafte Fakten , die immer im Kontext bleiben sollen.
• Skills speichern längere Abläufe , die nur bei Relevanz geladen werden sollen.
• Beide werden vom Agenten selbst erstellt und gepflegt, sodass er dasselbe Problem nie zweimal auf dieselbe Weise löst.

Da es sich um einen autonomen Schreibpfad handelt, umfasst Hermes ein Write-Approval-Gate (memory.write_approval / skills.write_approval). Standardmäßig deaktiviert — es schreibt frei —, doch Sie können es einschalten, sodass jeder Speichervorgang, insbesondere die unbeauftragten Hintergrundschreibvorgänge, zunächst gestaged und geprüft wird (/memory pending, /skills diff <id>, /skills approve), bevor er in Ihr Profil gelangt.

Quellen: Hermes docs — Persistent Memory https://hermes-agent.nousresearch.com/docs/user-guide/features/memory · Hermes docs — Skills System https://hermes-agent.nousresearch.com/docs/user-guide/features/skills · (Nudge-Intervalle im Quellcode verifiziert agent/agent_init.py)

Memory: Zwei Dateien, kuratiert wie ein echtes Gedächtnis

Hermes verwaltet begrenztes, kuratiertes Memory in zwei Dateien unter ~/.hermes/memories/:

File        | Purpose                                                                  | Cap                      
------------------------------------------------------------------------------------------------------------------
`MEMORY.md` | Agent's personal notes — environment facts, conventions, lessons learned | 2,200 chars (~800 tokens)
`USER.md`   | User profile — preferences, communication style, expectations            | 1,375 chars (~500 tokens)

Zu Beginn jeder Session werden sie als eingefrorener Snapshot — jeder Eintrag durch ein § Trennzeichen getrennt, mit einem Header, der den Speicher und dessen Auslastung anzeigt. Der Snapshot ändert sich während einer Session nicht (das sichert den Prompt-Cache); neue Schreibvorgänge werden sofort auf die Festplatte geschrieben, sind aber erst in der nächsten Session sichtbar. Es gibt keine read Aktion — der Agent sieht sein Gedächtnis einfach im Kontext.

Das Gedächtnis ist kuratiert, kein Log:

• Keine automatische Komprimierung. Wenn ein Schreibvorgang das Limit überschreiten würde, gibt das memory Werkzeug einen Fehler zurück, der die aktuellen Einträge anzeigt; der Agent konsolidiert oder löscht dann selbst Einträge — indem er sich überschneidende Fakten zu kürzeren zusammenfasst — bevor er es erneut versucht.
• Der Agent speichert proaktiv — Präferenzen („Ich bevorzuge TypeScript“), Umgebungsfakten, Korrekturen, Konventionen, abgeschlossene Arbeiten. Triviale oder wiederherstellbare Fakten sowie Rohdaten werden übersprungen.
• Einträge werden vor der Annahme auf Prompt-Injection- und Exfiltrationsmuster gescannt, exakte Duplikate werden abgelehnt.
• Über das Gedächtnis hinaus session_search kann der Agent seinen gesamten Gesprächsverlauf in SQLite durchsuchen — „Wurde letzte Woche über X gesprochen?“ wird über den FTS5-Index beantwortet, ohne LLM-Token zu verbrauchen.

Die praktische Erkenntnis: Gedächtnis ist darauf ausgelegt, klein und dichtzu sein, wie die Notizen eines Profis — kein Transkript.

Quelle: hermes docs — Persistent Memory https://hermes-agent.nousresearch.com/docs/user-guide/features/memory

Externes Gedächtnis: Honcho und die Provider-Ebene

Integrierte Dateien sind der Standard, aber Hermes wird mit 8 externen Gedächtnis-Providern ausgeliefert — Honcho, OpenViking, Mem0, Hindsight, Holographic, RetainDB, ByteRover, Supermemory — die parallel zum integrierten Gedächtnis laufen (es nie ersetzen) und semantische Suche, Wissensgraphen sowie automatische Faktenextraktion hinzufügen. Nur einer ist jeweils aktiv.

Hervorzuheben ist Honcho von Plastic Labs https://github.com/plastic-labs/honcho, ein KI-natives Memory-Backend, das dialektisches Reasoning: Nach jedem Gesprächsabschnitt analysiert es den Austausch und leitet Erkenntnisse über Ihre Präferenzen, Ziele und Arbeitsweise ab — und baut so ein sich vertiefendes Modell Ihrer Person auf, das über das hinausgeht, was Sie jemals explizit geäußert haben. Während Hermes’ integriertes Memory manuell kuratierte Notizen sind, ist Honcho automatisch abgeleitetes User Modeling.

Es ist um zwei Peers herum aufgebaut — einen User-Peer und einen KI-Peer –, die beide in den System-Prompt injiziert werden, sodass Hermes sowohl weiß, mit wem es spricht, als auch, was es weiß. Hermes stellt vier Honcho-Werkzeuge bereit:

• honcho_profile — schnelle Peer-Card (ohne LLM), kuratierte Schlüsselfakten über Sie
• honcho_search — semantische Suche über das Memory
• honcho_context — dialektische Q&A, die Antworten aus der Historie synthetisiert
• honcho_conclude — schreibt dauerhafte Fakten, wenn Sie Präferenzen oder Korrekturen äußern

Die Einrichtung erfolgt mit einem Befehl: hermes memory setup, wählen Sie „honcho“ aus und geben Sie Ihre Basis-URL an. Der klassische Test: Teilen Sie ihm Ihre Lieblingssprache und Ihre Präferenz für Dark Mode mit, starten Sie eine komplett neue Session und fragen Sie, was es über Ihre Vorlieben weiß.

Quelle: Hermes docs — Honcho Memory https://hermes-agent.nousresearch.com/docs/user-guide/features/honcho · Hermes docs — Memory Providers https://hermes-agent.nousresearch.com/docs/user-guide/features/memory-providers · Honcho + Hermes Integration Guide https://github.com/plastic-labs/honcho/blob/main/docs/v3/guides/integrations/hermes.mdx

Apps mit MCP verbinden

Der zweite Pfeiler des „Mitarbeiter“-Rahmens ist die Anbindung der benötigten Apps. Hermes verfügt über einen nativen MCP https://modelcontextprotocol.io/ -Client (Model Context Protocol). MCP ist der Open Standard für die Verbindung von KI-Anwendungen mit externen Systemen — ein Open-Source-Protokoll, eingeführt von Anthropic https://www.anthropic.com/news/model-context-protocol — statt also für jeden Dienst ein natives Hermes-Werkzeug zu schreiben, bindet man Server ein, die Werkzeuge bereitstellen.

Server unter mcp_servers konfigurieren ~/.hermes/config.yaml; beim Start verbindet sich Hermes, erkennt automatisch die Werkzeuge jedes Servers und registriert sie in jedem Plattform-Werkzeugsatz unter einem mcp_{server}_{tool} Präfix. Zwei Transporttypen:

• stdio — Server als Subprozess starten (npx, uvx, beliebiger Befehl)
• HTTP — auf eine entfernte oder gemeinsame Server-URL verweisen

Ein kleines Beispiel:

mcp_servers:
  time:
    command: "uvx"
    args: ["mcp-server-time"]

Dann fragt man Hermes einfach nach der aktuellen Uhrzeit, und es nutzt mcp_time_get_current_time wie jedes eingebaute Werkzeug. Hermes liefert außerdem einen kuratierten Katalog von Nous-geprüften MCP-Servern mit — hermes mcp install n8n und führt stdio-MCP-Subprozesse aus Sicherheitsgründen mit einer gefilterten Umgebung aus (keine geleakten API-Schlüssel, sofern sie nicht explizit übergeben werden), schwärzt Zugangsdaten in Fehlermeldungen und unterstützt MCPs sampling/createMessage Fähigkeit für Workflows mit Agenten im Loop.

Quelle: Hermes-Dokumentation — MCP https://hermes-agent.nousresearch.com/docs/user-guide/features/mcp · modelcontextprotocol.io https://modelcontextprotocol.io/ · Anthropic-Ankündigung https://www.anthropic.com/news/model-context-protocol

Autopilot mit cron

Das klassische „Mitarbeiter“-Feature: Arbeit, die ohne Ihr Zutun läuft. Hermes plant sie mit cron, gesteuert über ein einziges cronjob Werkzeug, die hermes cron CLI, oder /cron im Chat — keine CLI erforderlich.

/cron add "every 2h" "Check server status"
/cron add "every 1h" "Summarize new feed items" --skill blogwatcher

• Zeitpläne können eine Dauer ("30m", "2h"), eine Formulierung ("every monday 9am"), einen 5-Felder-cron-Ausdruck ("0 9 * * *") oder einen ISO-Zeitstempel für einmalige Ausführung sein.
• Aufträge können null, eine oder mehrere Skillsanhängen, auf einem pro-Auftrag-Modell/Anbieterlaufen und Ergebnisse an den ursprünglichen Chat, lokale Dateien oder konfigurierte Plattformziele liefern.
• Agentenloser Modus: ein Skript nach Zeitplan, dessen stdout wortgetreu ausgeliefert wird — ohne LLM-Beteiligung.
• Eine cron-Sitzung kann nicht rekursiv weitere cron-Aufträge erstellen (keine unkontrollierten Planungs-Schleifen), und ein Konfigurationsfehler wird einmalig angezeigt, statt bei jedem Durchlauf Token zu verbrauchen.

Für wiederkehrende Arbeit innerhalb einer Sitzung gibt es außerdem /loop (timergesteuert) und /goal (beurteilungsgesteuert „weiterarbeiten, bis fertig“), aber cron ist derjenige, der Neustarts überlebt und unbeaufsichtigt läuft — der echte Autopilot.

Quelle: Hermes docs — Scheduled Tasks (Cron) https://hermes-agent.nousresearch.com/docs/user-guide/features/cron · Hermes docs — Recurring Loops https://hermes-agent.nousresearch.com/docs/user-guide/features/loops

Skills sind die SOPs, die es sich selbst schreibt

Skills sind prozedurales Gedächtnis — bedarfsgerechte Wissensdokumente, die der Agent nur bei Relevanz lädt (progressive Offenlegung). Wenn der Agent einen nicht-trivialen Workflow erarbeitet, in eine Sackgasse gerät und den funktionierenden Pfad findet oder Sie seine Vorgehensweise korrigieren, speichert er den Ansatz über das skill_manage Tool (create / patch / edit / delete / write_file / remove_file). Das ist der „Mitarbeiter:innen-Wachstum“-Motor: es löst nie dasselbe Problem auf dieselbe Weise.

• Skills liegen in ~/.hermes/skills/ als SKILL.md Dateien vor und folgen dem agentskills.io https://agentskills.io/specification -Open-Standard.
• Sie werden auf drei Ebenen geladen, um Token zu sparen: skills_list() (Index) → skill_view(name) (vollständiger Inhalt) → skill_view(name, path) (eine bestimmte Referenzdatei).
• Jeder installierte Skill steht auf jeder Oberfläche als /skill-name Slash-Command zur Verfügung — und Bundles (/backend-dev) fassen mehrere Skills unter einem Befehl zusammen.
• Der Skills Hub (hermes skills browse / search / install) bezieht Skills aus offiziellen optionalen Skills, skills.sh, /.well-known/skills, direkten URLs und GitHub — mit Sicherheitsprüfung.
• Ein Curator -Hintergrundsystem verfolgt die Nutzung, markiert veraltete agentenerstellte Skills und archiviert sie (löscht nie), damit der Katalog nicht mit engen Duplikaten überfüllt wird.

Quelle: Hermes-Dokumentation — Skills System https://hermes-agent.nousresearch.com/docs/user-guide/features/skills · Hermes-Dokumentation — Curator https://hermes-agent.nousresearch.com/docs/user-guide/features/curator

Sub-Agenten und Profile: ein Team, nicht nur eine Mitarbeiterin

Hermes skaliert von einer Assistentin zu einer kleinen Organisation:

• Sub-Agenten — delegate_task startet einen isolierten Sub-Agenten mit eigenem Kontext und Terminal-Session, um Teilaufgaben parallel zu bearbeiten (Batch-Aufgaben, Hintergrund-Handles und leaf vs. orchestrator Rollen). Recherchieren während des Entwurfs, Debuggen während des Testens.
• Profile — mehrere unabhängige Hermes-Agenten auf einem Rechner, jeder mit eigenem config.yaml, API-Schlüsseln, Speicher, Sessions, Skills und Identität. hermes profile create coder liefert sofort einen coder chat Befehl mit eigener Persönlichkeit. Die Dokumentation warnt: Niemals zwei Agenten auf dasselbe Profil verweisen — jeder erhält sein eigenes, und der Speicher wird über einen externen Anbieter geteilt.

Die Persönlichkeit steckt in einer Datei

Wo die Persönlichkeit und der Ton eines Agenten verankert sind, ist genauso wichtig wie seine Werkzeuge. Bei Hermes ist das SOUL.md — die primäre Identität des Agenten, geladen aus HERMES_HOME/SOUL.md (z. B. ~/.hermes/SOUL.md) in Slot #1 des System-Prompts. Hermes legt eine Standardversion an, falls keine existiert, und überschreibt Ihre niemals. Eine Datei wie soul.md sorgt für einen konsistenten Ton in jeder Interaktion — der Unterschied zwischen einem Werkzeug und einer Kollegin.

So gestalten Sie ein gutes SOUL.md:

• Stabil über Kontexte hinweg — sie begleitet den Agenten überall, daher sollte sie allgemein gehalten sein, nicht projektspezifisch.
• Fokus auf Kommunikation und Identität, nicht auf Aufgabenanweisungen: Tonfall, Kommunikationsstil, Grad der Direktheit, Umgang mit Unsicherheit und Meinungsverschiedenheiten.
• Präzise genug, um die Stimme zu formen — ein knapper Beispiel-Prompt aus der Dokumentation: „You are a pragmatic senior engineer with strong taste. You optimize for truth, clarity, and usefulness over politeness theater.“
• Einmalige Anweisungen, Dateipfade und Repo-Konventionen heraushalten — diese gehören in AGENTS.md (Projektkontext) und .hermes.md / CLAUDE.md / .cursorrules werden ebenfalls erkannt. Die Regel: Wenn es überall mitfolgen soll → SOUL.md; wenn es zu einem Projekt gehört → AGENTS.md.
• Session-Overlays (/personality teacher) legen sich darüber, um temporäre Moduswechsel zu ermöglichen, ohne das dauerhafte Default-Profil zu verändern.

Quelle: Hermes docs — Personality & SOUL.md https://hermes-agent.nousresearch.com/docs/user-guide/features/personality · Hermes docs — Context Files https://hermes-agent.nousresearch.com/docs/user-guide/features/context-files

Das Fünf-Schritte-Rezept, neu betrachtet

Damit wird das Rezept zu etwas, das man tatsächlich im Zeitplan umsetzen kann — mit Gedächtnis und einer Persönlichkeit:

1. Beginne mit einem KI-Agenten — Hermes, in einem Profil mit einer SOUL.md SOUL.md-Identität.
2. Verbinde die Apps , die er braucht — über MCP-Server, die nativen Werkzeuge oder die Memory-Provider.
3. Lass die Selbstoptimierungsschleife lernen — Gedächtnis für Fakten, Skills für Abläufe, etwa alle 10 Durchläufe.
4. Feile am Output, bis er passt — iteriere am Skill, bis der Workflow sitzt.
5. Automatisieren Sie es mit autopilot , damit es weiterliefert, ohne dass Sie nachfragen müssen.

Der Unterschied zwischen einem Agenten, der Ihren Computer nutzen kann, und einem KI-Mitarbeiter besteht darin, dass der Mitarbeiter sich an Sie erinnert, Ihre Arbeitsmuster lernt, sein eigenes Runbook schreibt und pünktlich erscheint. Hermes erledigt all das — und das meiste davon, ohne dazu aufgefordert zu werden.

Dass Ihr Agent nützliche Aufgaben ohne Aufforderung weiter ausführt, ist die wichtigste Idee für den Aufbau nützlicher Workflows.

Quellen

• Hermes Agent Repository (Nous Research) — https://github.com/NousResearch/hermes-agent
• Hermes Agent Dokumentationsindex — https://hermes-agent.nousresearch.com/docs/
• Persistenter Speicher (MEMORY.md / USER.md) — https://hermes-agent.nousresearch.com/docs/user-guide/features/memory
• Memory Providers — https://hermes-agent.nousresearch.com/docs/user-guide/features/memory-providers
• Honcho Memory — https://hermes-agent.nousresearch.com/docs/user-guide/features/honcho
• Honcho × Hermes Integration — https://github.com/plastic-labs/honcho/blob/main/docs/v3/guides/integrations/hermes.mdx
• MCP — https://hermes-agent.nousresearch.com/docs/user-guide/features/mcp
• Model Context Protocol (offener Standard) — https://modelcontextprotocol.io/
• Introducing the Model Context Protocol (Anthropic) — https://www.anthropic.com/news/model-context-protocol
• Geplante Aufgaben (Cron) — https://hermes-agent.nousresearch.com/docs/user-guide/features/cron
• Wiederkehrende Schleifen (/loop, /goal) — https://hermes-agent.nousresearch.com/docs/user-guide/features/loops
• Skills-System — https://hermes-agent.nousresearch.com/docs/user-guide/features/skills
• Curator — https://hermes-agent.nousresearch.com/docs/user-guide/features/curator
• Persönlichkeit & SOUL.md — https://hermes-agent.nousresearch.com/docs/user-guide/features/personality
• Kontextdateien — https://hermes-agent.nousresearch.com/docs/user-guide/features/context-files
• Profile — https://hermes-agent.nousresearch.com/docs/user-guide/profiles
• Nous Research — https://nousresearch.com/
• agentskills.io (Skill-Spezifikation) — https://agentskills.io/specification