Autonomous Agent Harness

Was macht Autonomous Agent Harness?

Kombiniere die Sitzungswerkzeuge von Claude Code mit separat konfigurierten Integrationen für Planung, Speicher und Computer-Nutzung. Dies ist ein Setup-Muster, kein gebündelter, ständig laufender Runtime.

Einwilligungs- und Sicherheitsgrenzen

Autonomer Betrieb muss explizit vom Benutzer angefordert und eingegrenzt werden. Erstelle keine Zeitpläne, versende keine Remote-Agenten, schreibe keinen persistenten Speicher, verwende keine Computer-Steuerung, veröffentliche keine externen Inhalte, bearbeite keine Ressourcen Dritter oder handele in privaten Kommunikationen, es sei denn, der Benutzer hat diese Fähigkeit und den Zielarbeitsbereich für das aktuelle Setup genehmigt.

Bevorzuge Trockenläufe und lokale Warteschlangendateien, bevor du wiederkehrende oder ereignisgesteuerte Aktionen aktivierst. Halte Anmeldeinformationen, private Arbeitsbereichsexporte, persönliche Datensätze und kontospezifische Automatisierungen aus wiederverwendbaren ECC-Artefakten heraus.

Wann aktivieren

• Der Benutzer möchte einen Agenten, der kontinuierlich oder nach einem Zeitplan läuft
• Einrichtung automatisierter Workflows, die regelmäßig ausgelöst werden
• Aufbau eines persönlichen KI-Assistenten, der sich Kontext über Sitzungen hinweg merkt
• Der Benutzer sagt "führe das jeden Tag aus", "überprüfe das regelmäßig", "beobachte weiterhin"
• Möchte Funktionalität von Hermes, AutoGPT oder ähnlichen autonomen Agenten-Frameworks replizieren
• Benötigt Computer-Nutzung in Kombination mit geplanter Ausführung

Architektur

┌──────────────────────────────────────────────────────────────┐
│                    Claude Code Runtime                        │
│                                                              │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌─────────────┐ │
│  │  Crons   │  │ Dispatch │  │ Memory   │  │ Computer    │ │
│  │ Schedule │  │ Remote   │  │ Store    │  │ Use         │ │
│  │ Tasks    │  │ Agents   │  │          │  │             │ │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └──────┬──────┘ │
│       │              │             │                │        │
│       ▼              ▼             ▼                ▼        │
│  ┌──────────────────────────────────────────────────────┐    │
│  │              ECC Skill + Agent Layer                  │    │
│  │                                                      │    │
│  │  skills/     agents/     commands/     hooks/        │    │
│  └──────────────────────────────────────────────────────┘    │
│       │              │             │                │        │
│       ▼              ▼             ▼                ▼        │
│  ┌──────────────────────────────────────────────────────┐    │
│  │              MCP Server Layer                        │    │
│  │                                                      │    │
│  │  memory    github    exa    supabase    browser-use  │    │
│  └──────────────────────────────────────────────────────┘    │
└──────────────────────────────────────────────────────────────┘

Kernkomponenten

1. Persistenter Speicher

Nutze das integrierte Speichersystem von Claude Code, erweitert um einen MCP-Speicher-Server für strukturierte Daten.

Integrierter Speicher (~/.claude/projects/*/memory/):

• Benutzereinstellungen, Feedback, Projektkontext
• Gespeichert als Markdown-Dateien mit Frontmatter
• Automatisch beim Sitzungsstart geladen

MCP-Speicher-Server (strukturierter Wissensgraph):

• Entitäten, Beziehungen, Beobachtungen
• Abfragbare Graphenstruktur
• Sitzungsübergreifende Persistenz

Speichermuster:

# Kurzfristig: aktueller Sitzungskontext
Verwende TodoWrite für die Aufgabenverfolgung innerhalb der Sitzung

# Mittelfristig: Projekt-Speicherdateien
Schreibe in ~/.claude/projects/*/memory/ für sitzungsübergreifenden Abruf

# Langfristig: MCP-Wissensgraph
Verwende mcp__memory__create_entities für permanente strukturierte Daten
Verwende mcp__memory__create_relations für Beziehungszuordnung
Verwende mcp__memory__add_observations für neue Fakten über bekannte Entitäten

2. Geplante Operationen (Crons)

Verwende die nativen geplanten Aufgaben von Claude Code für wiederkehrende Aufforderungen innerhalb einer interaktiven Sitzung. Diese Aufgaben sind sitzungsgebunden; für Arbeiten, die unabhängig von einer offenen Sitzung ausgeführt werden müssen, ist ein externer Scheduler erforderlich. Für /loop wird kein MCP-Scheduler-Server benötigt.

Einrichten eines Cron:

# In einer interaktiven Claude Code-Sitzung
/loop 30m Überprüfe offene PRs in diesem Repository und fasse CI-Fehler zusammen.

Für einen einmaligen Aufruf aus einer Shell heraus setze das Arbeitsverzeichnis vor dem Aufruf der CLI:

cd "/pfad/zum/repo" && claude -p "Überprüfe offene PRs und fasse sie zusammen"

Verwende einen OS-Scheduler oder einen CI-Plan, um diesen Befehl wiederholt auszuführen, wenn keine interaktive Sitzung läuft. Konfiguriere die Authentifizierung und die Tool-Berechtigungen des Ausführenden separat.

Nützliche Cron-Muster:

Muster	Zeitplan	Anwendungsfall
Tägliches Standup	0 9 * * 1-5	PRs, Issues, Deploy-Status überprüfen
Wöchentliche Überprüfung	0 10 * * 1	Code-Qualitätsmetriken, Testabdeckung
Stündlicher Monitor	0 * * * *	Produktionszustand, Fehlerraten prüfen
Nächtlicher Build	0 2 * * *	Vollständige Testsuite ausführen, Sicherheitsscan
Vor dem Meeting	*/30 * * * *	Kontext für bevorstehende Meetings vorbereiten

3. Dispatch / Remote-Agenten

Lasse einen authentifizierten CI-Job oder Webhook-Empfänger Claude Code in einem ihm gehörenden Arbeitsbereich aufrufen. Der unterstützte Einstiegspunkt ist der programmatische CLI-Modus, kein öffentlicher Anthropic-Dispatch-Endpunkt.

Dispatch-Muster:

# Innerhalb des CI-Arbeitsbereichs ausführen
cd "/pfad/zum/repo" && claude -p "Build auf main fehlgeschlagen. Diagnostiziere den Fehler."

# Von Webhook aus auslösen
# GitHub-Webhook -> authentifizierter CI-Runner -> claude -p -> überprüfbares Ergebnis

# Von einem anderen Agenten aus auslösen
claude -p "Analysiere die Ausgabe des Sicherheitsscans und erstelle Issues für die Ergebnisse"

4. Computer-Nutzung

Die Computer-Steuerung benötigt eine separat konfigurierte Integration. Das Computer-Use-Tool und die Referenzumgebung von Anthropic erfordern eine Anwendung, die Tool-Aufrufe in einer isolierten Desktop-Umgebung ausführt. Das Hinzufügen eines MCP-Paketnamens stellt diese Umgebung nicht bereit.

Fähigkeiten:

• Browser-Automatisierung (navigieren, klicken, Formulare ausfüllen, Screenshots)
• Desktop-Steuerung (Apps öffnen, tippen, Maussteuerung)
• Dateisystemoperationen über die CLI hinaus

Anwendungsfälle innerhalb des Harness:

• Automatisierte Tests von Web-Oberflächen
• Formularausfüllen und Dateneingabe
• Screenshot-basierte Überwachung
• Multi-App-Workflows

5. Aufgabenwarteschlange

Verwalte eine persistente Warteschlange von Aufgaben, die Sitzungsgrenzen überdauern.

Implementierung:

# Aufgabenpersistenz über Speicher
Schreibe Aufgabenwarteschlange in ~/.claude/projects/*/memory/task-queue.md

# Aufgabenformat
---
name: task-queue
type: project
description: Persistente Aufgabenwarteschlange für autonomen Betrieb
---

## Aktive Aufgaben
- [ ] PR #123: Überprüfen und genehmigen, wenn CI grün
- [ ] Deploy überwachen: /health alle 30 Minuten für 2 Stunden prüfen
- [ ] Recherche: Finde 5 Leads im Bereich KI-Tools

## Abgeschlossen
- [x] Tägliches Standup: 3 PRs, 2 Issues überprüft

Ersetzen von Hermes

Hermes-Komponente	ECC-Äquivalent	Wie
Gateway/Router	CLI + externer Scheduler	Ein authentifizierter Runner startet Agentensitzungen
Speichersystem	Claude-Speicher + MCP-Speicher-Server	Integrierte Persistenz + Wissensgraph
Tool-Registry	MCP-Server	Dynamisch geladene Tool-Anbieter
Orchestrierung	ECC-Skills + Agenten	Skill-Definitionen steuern das Agentenverhalten
Computer-Nutzung	Separat konfigurierte Integration	Browser- oder Desktop-Steuerung in isolierter Umgebung
Kontext-Manager	Sitzungsverwaltung + Speicher	ECC 2.0 Sitzungslebenszyklus
Aufgabenwarteschlange	Speicher-persistierte Aufgabenliste	TodoWrite + Speicherdateien

Setup-Anleitung

Schritt 1: MCP-Server konfigurieren

Memory MCP ist optional. Der MCP-Referenz-Speicher-Server wird als @modelcontextprotocol/server-memory veröffentlicht; Version 2026.8.31 wurde am 2026-09-07 im öffentlichen npm-Registry verifiziert. Es handelt sich um eine Referenzimplementierung, nicht um einen ECC-gebündelten Dienst.

Nachdem du dieses Paket überprüft und seine Verwendung genehmigt hast, füge diesen Eintrag in die benutzerspezifische MCP-Konfiguration in ~/.claude.json ein, wobei bestehende Einstellungen erhalten bleiben. Ersetze MEMORY_FILE_PATH durch einen absoluten Pfad in einem privaten Verzeichnis, das dir gehört. Siehe Claude Code MCP-Konfiguration für die CLI-Registrierung und die Windows cmd /c npx-Konfiguration.

{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/[email protected]"],
      "env": {
        "MEMORY_FILE_PATH": "/absoluter/pfad/zum/privaten/memory.jsonl"
      }
    }
  }
}

Registriere keine vermuteten oder unveröffentlichten npm-Pakete: npx -y würde alles ausführen, was später unter diesem Namen veröffentlicht wird. Überprüfe das genaue Paket, den Herausgeber und die Version, bevor du einen weiteren Server hinzufügst. Planung und Computer-Nutzung erfordern nicht die drei zuvor hier aufgeführten unveröffentlichten Paketnamen.

Schritt 2: Basis-Crons erstellen

Für das Abfragen während einer interaktiven Sitzung gib ein:

/loop 30m Überprüfe offene PRs in diesem Repository und fasse CI-Fehler zusammen.

Für tägliche oder wöchentliche Arbeiten, die eine geschlossene Sitzung überdauern müssen, konfiguriere einen externen Scheduler, wie einen OS-Cron-Job oder GitHub Actions, um den einmaligen Befehl aus Schritt 2 der Kernkomponenten auszuführen. Der Aufruf von claude -p, um einen Zeitplan anzufordern, stellt keinen dauerhaft laufenden Scheduler bereit. Wähle den Zeitplan, den Arbeitsbereich und die erlaubten Aktionen explizit aus, bevor du ihn aktivierst.

Schritt 3: Speichergraphen initialisieren

# Starte deine Identität und deinen Kontext
claude -p "Erstelle Speicherentitäten für: mich (Benutzerprofil), meine Projekte, meine wichtigsten Kontakte. Füge Beobachtungen zu aktuellen Prioritäten hinzu."

Schritt 4: Computer-Nutzung aktivieren (optional)

Folge der oben verlinkten Referenzumgebung für Computer-Nutzung oder der Dokumentation für eine spezifische von dir überprüfte Browser-Integration. Gewähre nur die erforderlichen Berechtigungen und überprüfe eine harmlose Aktion in der isolierten Umgebung, bevor du sie zu geplanten Workflows hinzufügst.

Beispiel-Workflows

Autonomer PR-Reviewer

Cron: alle 30 Minuten während der Arbeitszeit
1. Prüfe auf neue PRs in überwachten Repos
2. Für jeden neuen PR:
   - Branch lokal pullen
   - Tests ausführen
   - Änderungen mit dem Code-Reviewer-Agenten überprüfen
   - Review-Kommentare über GitHub MCP posten
3. Speicher mit Review-Status aktualisieren

Persönlicher Recherche-Agent

Cron: täglich um 6 Uhr
1. Gespeicherte Suchanfragen im Speicher prüfen
2. Exa-Suchen für jede Anfrage ausführen
3. Neue Ergebnisse zusammenfassen
4. Mit den Ergebnissen von gestern vergleichen
5. Zusammenfassung in den Speicher schreiben
6. Priorisierte Elemente für die morgendliche Überprüfung markieren

Meeting-Vorbereitungs-Agent

Auslöser: 30 Minuten vor jedem Kalenderereignis
1. Kalenderereignisdetails lesen
2. Speicher nach Kontext zu Teilnehmern durchsuchen
3. Aktuelle E-Mail-/Slack-Threads mit Teilnehmern abrufen
4. Gesprächsthemen und Agenda-Vorschläge vorbereiten
5. Vorbereitungsdokument in den Speicher schreiben

Einschränkungen

• Native geplante Aufforderungen teilen sich ihre interaktive Sitzung. Externe Scheduler-Aufrufe starten separate Sitzungen, sofern nicht explizit fortgesetzt.
• Computer-Nutzung erfordert explizite Berechtigungsgewährung. Gehe nicht von Zugriff aus.
• CLI-Automatisierung verbraucht weiterhin Modellnutzung und unterliegt den Limits des konfigurierten Anbieters. Wähle geeignete Scheduler-Intervalle.
• Speicherdateien sollten kurz gehalten werden. Archive alte Daten, anstatt Dateien unbegrenzt wachsen zu lassen.
• Überprüfe immer, ob geplante Aufgaben erfolgreich abgeschlossen wurden. Füge Fehlerbehandlung zu Cron-Aufforderungen hinzu.