---
description: "Der Daemon führt Ausführungen von Agenten aus. Registriere eine oder mehrere Runtimes, um die Ausführungskapazität zu skalieren."
---

# Daemon-Installation

Der Daemon führt Ausführungen von Agenten aus. Registriere eine oder mehrere Runtimes, um die Ausführungskapazität zu skalieren.

![Runtime Management](/documentation/blume-assets/content/docs/img/screenshots/08-runtimes.png)

## Schnellstart (Docker)

```bash
# 1. Get a registration token
# In Agent Orchestrator: Runtimes → Register Runtime → copy token

# 2. Run the daemon
docker run -d \
  --name agenthub-daemon \
  -e AGENTHUB_SERVER_URL=http://your-ao-server:8082 \
  -e AGENTHUB_TOKEN=<your-token> \
  -e AGENTHUB_RUNTIME_NAME="My Runtime" \
  -v agenthub-workspaces:/root/agenthub_workspaces \
  simplifierag/miri:daemon
```

## Schnellstart (lokal / Bare Metal)

```bash
# 1. Install dependencies
# Python 3.11+, git, opencode (auto-installed by daemon)

# 2. Get registration token from AO UI
export AGENTHUB_SERVER_URL=http://your-ao-server:8082
export AGENTHUB_TOKEN=<your-token>
export AGENTHUB_RUNTIME_NAME="Local Runtime"

# 3. Run
python3 agenthub_daemon.py start --foreground
```

## Umgebungsvariablen

| Variable | Erforderlich | Standard | Beschreibung |
|----------|----------|---------|-------------|
| `AGENTHUB_SERVER_URL` | Ja | — | Backend-URL (z. B. `http://localhost:8082`) |
| `AGENTHUB_TOKEN` | Ja | — | Registrierungs-Token aus AO |
| `AGENTHUB_RUNTIME_NAME` | Nein | `Docker Runtime` | Anzeigename in AO |
| `AGENTHUB_WORKSPACE_ID` | Nein | — | An einen bestimmten Workspace binden |
| `AGENTHUB_OPENCODE_PATH` | Nein | `opencode` | Pfad zur opencode-Binärdatei |
| `AGENTHUB_OPENCODE_MODEL` | Nein | — | Standardmodell für Ausführungen |
| `AGENTHUB_MAX_CONCURRENT` | Nein | `3` | Max. parallele Ausführungen |
| `AGENTHUB_POLL_INTERVAL` | Nein | `5000` | Abfrageintervall zum Backend (ms) |
| `AGENTHUB_IDLE_WATCHDOG` | Nein | `1800000` | Leerlauf-Timeout (ms) |
| `AGENTHUB_RECONNECT_DELAY` | Nein | `5000` | Wartezeit vor erneutem Verbindungsaufbau zum Backend (ms) |
| `AGENTHUB_LOG_MAX_BYTES` | Nein | `10485760` | Größe für die Log-Rotation |
| `AGENTHUB_LOG_BACKUP_COUNT` | Nein | `5` | Anzahl aufbewahrter rotierter Log-Dateien |
| `AGENTHUB_STATE_DIR` | Nein | `<workspaces dir>/.daemon-state` | Ort, an dem der Daemon seine gespeicherten Runtime-Zugangsdaten ablegt |
| `AGENTHUB_DRAIN_SECONDS` | Nein | `60` | Wie lange ein stoppender Daemon auf laufende Arbeit wartet |
| `AGENTHUB_WUD_URL` | Nein | — | URL des Watchtower Update Daemon |

## Docker Compose (Produktion)

```yaml
# docker-compose.daemon.prod.yaml
services:
  daemon:
    image: simplifierag/miri:daemon
    environment:
      AGENTHUB_SERVER_URL: https://your-ao.com
      AGENTHUB_TOKEN: ${AGENTHUB_TOKEN}
      AGENTHUB_RUNTIME_NAME: "Production Runtime"
    volumes:
      - daemon-workspaces:/root/agenthub_workspaces
    restart: unless-stopped

volumes:
  daemon-workspaces:
```

Ausführen: `docker compose -f docker-compose.daemon.prod.yaml --env-file .env.daemon.prod up -d`

## systemd-Dienst (Linux)

```bash
# Install (as root)
curl -fsSL https://raw.githubusercontent.com/simplifierag/sf-agent-os/main/daemon/install.sh | bash -s -- \
  --server https://your-ao.com \
  --token <token> \
  --name "Production Runtime"

# Manage
systemctl status agenthub-daemon
systemctl restart agenthub-daemon
journalctl -u agenthub-daemon -f
```

## opencode-Integration

Der Daemon benötigt **opencode**, um Ausführungen durchzuführen. Die Installation übernimmt er automatisch:

- **Docker-Image** — Vorinstalliert unter `/root/.opencode/bin/opencode`
- **Lokal** — Wird beim ersten Start automatisch installiert (`curl ... | bash`)
- **Version** — In `daemon/Dockerfile` auf eine kompatible Version festgelegt

### Modellkonfiguration

Standardmodell pro Runtime festlegen:
```bash
export AGENTHUB_OPENCODE_MODEL=anthropic/claude-3-5-sonnet
```

Agenten können das Modell pro Ausführung über ihre Ausführungseinstellungen überschreiben.

## Registrierungs-Tokens, Neustarts und Updates

- **Ein Registrierungs-Token funktioniert nur einmal und läuft ab.** **Runtimes** → **Runtime registrieren** zeigt den Token mit einem Countdown „Läuft ab in …" an (24 Stunden). Er ist verbraucht, sobald sich ein Daemon das erste Mal damit registriert.
- **Danach braucht ein Daemon keinen neuen Token.** Bei der Registrierung speichert er seine Runtime-Zugangsdaten (`credentials.json`, nur für den Benutzer des Daemons lesbar) in seinem State-Verzeichnis — standardmäßig `.daemon-state` im Workspaces-Verzeichnis. Ein Neustart, ein Neuanlegen des Containers oder ein Image-Update (auch über WUD) setzt dann dieselbe Runtime anhand dieser Datei fort.
- **Lege das State-Verzeichnis auf ein Volume.** Die Compose-Dateien legen es im Workspaces-Volume des Daemons ab. Geht dieses Volume verloren — oder wird der Daemon mit einer anderen Server-URL, einem anderen Runtime-Namen oder einem anderen Token gestartet —, registriert er sich neu und braucht über **Runtime registrieren** einen frischen Token.
- **Beim Stoppen wird laufende Arbeit abgeschlossen.** Beim Stoppen nimmt der Daemon keine neuen Ausführungen mehr an und wartet bis zu `AGENTHUB_DRAIN_SECONDS` auf laufende. Noch nicht beendete Ausführungen gehen sofort zurück in die Warteschlange und werden erneut aufgenommen. Gib deinem Container oder Dienst ein Stopp-Timeout, das über diesem Wert liegt — die Compose-Dateien verwenden 90 Sekunden; ein einfaches `docker stop` mit den standardmäßigen 10 Sekunden würde das Warten verkürzen.

## WUD-Auto-Update (Watchtower)

Automatische Daemon-Updates aktivieren:

```bash
# In daemon compose, add WUD sidecar:
wud:
  image: getwud/wud:latest
  environment:
    WUD_WATCHER_LOCAL_WATCHBYDEFAULT: "false"
    WUD_SERVER_ENABLED: "true"
  labels:
    - "wud.watch.daemon=true"
    - "wud.trigger.miri=true"

# In daemon:
environment:
  AGENTHUB_WUD_URL: http://wud:3000
```

**So funktioniert es:**
1. Das Backend setzt das Flag `pendingUpdate` an der Runtime
2. Der Heartbeat des Daemons liefert das Flag aus
3. Der Daemon ruft WUD lokal auf → WUD lädt das neue Image → startet den Daemon neu
4. Zusätzlich wird alle 6 Stunden auf einen neuen `:latest`-Digest geprüft

## Entferntes Backend + lokaler Daemon

Gängiges Muster: AO-Backend in der Cloud, Daemon auf dem lokalen Rechner:

```bash
# Local machine
export AGENTHUB_SERVER_URL=https://your-cloud-ao.com
export AGENTHUB_TOKEN=<token-from-cloud-ao>
python3 agenthub_daemon.py start
```

- Der Daemon fragt das Cloud-Backend über HTTPS ab
- Git-Checkouts erfolgen lokal (dein Rechner, deine Zugangsdaten)
- Auslieferungen werden von deinem Rechner ins Git-Remote gepusht

## Mehrere Runtimes

Registriere mehrere Daemons für:
- **Verschiedene Umgebungen** — Dev / Staging / Prod
- **Verschiedene Hardware** — GPU fürs Programmieren, CPU für Analysen
- **Verschiedene Netzwerke** — On-Premises hinter einer Firewall + Cloud
- **Skalierung** — Ausführungen auf mehrere Rechner verteilen

Alle Runtimes erscheinen auf der Seite **Runtimes** mit individuellem Zustand und individueller Kapazität.

## Fehlerbehebung

| Problem | Lösung |
|-------|-----|
| „Connection refused" | Prüfe, ob `AGENTHUB_SERVER_URL` vom Daemon aus erreichbar ist |
| „Invalid token" | Token in AO neu erzeugen → Runtimes → Runtime registrieren |
| „opencode not found" | Docker: `simplifierag/miri:daemon` verwenden; lokal: PATH prüfen |
| „No models reported" | Sicherstellen, dass die opencode-Version die Modellerkennung unterstützt |
| „Workdir permission denied" | Volume-Mount: `-v agenthub-workspaces:/root/agenthub_workspaces` |
| „Git clone failed" | Zugangsdaten des Git-Ziels in den Projektdetails prüfen |

## Logs

```bash
# Docker
docker logs -f agenthub-daemon

# Local (foreground)
python3 agenthub_daemon.py start --foreground

# Systemd
journalctl -u agenthub-daemon -f
```

Log-Datei: `~/.agenthub/daemon.log` (rotierend, standardmäßig 5 Dateien à 10 MB)

## PID-Datei

`~/.agenthub/daemon.pid` — wird von den Befehlen `stop`/`restart`/`status` verwendet.

## Letzte Updates

- **opencode-Integration** — Automatische Installation, festgelegte Version, Modellkonfiguration
- **WUD-Auto-Update** — Vom Daemon vermittelte Remote-Updates über Watchtower
- **Unterstützung mehrerer Runtimes** — Viele Daemons registrieren, individuelle Zustandsüberwachung
- **Entferntes Backend** — Daemon lokal gegen eine Cloud-AO betreiben