> ## Documentation Index
> Fetch the complete documentation index at: https://novita.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Konfiguration

Konfigurieren Sie Modelle, verbinden Sie externe Messaging-Kanäle, richten Sie den On-Demand-Modus ein und erfahren Sie mehr über die Zuverlässigkeitsfunktionen Ihrer NovitaClaw-Instanz.

## On-Demand-Modus

Der On-Demand-Modus pausiert Ihre Sandbox automatisch nach einem konfigurierbaren Leerlaufzeitraum und setzt sie bei Zugriff wieder fort. Ideal für KI-Assistenten mit geringem Traffic, webhook-basierte IM-Integrationen und geplante Aufgaben. Keine Abrechnung, solange die Sandbox pausiert ist.

### Starten einer On-Demand-Sandbox

```bash Bash icon="terminal" theme={"system"}
# Default idle timeout: 300 seconds
novitaclaw launch --type on-demand

# Custom idle timeout (60–86400 seconds)
novitaclaw launch --type on-demand --idle-timeout 600
```

<Warning>
  Der On-Demand-Modus kann nicht mit `--mode node` kombiniert werden.
</Warning>

### Manuelles Pausieren und Fortsetzen

```bash Bash icon="terminal" theme={"system"}
# Pause a sandbox (zero billing while paused)
novitaclaw pause <SANDBOX_ID>

# Resume a sandbox (~1s to restore to pre-pause state)
novitaclaw resume <SANDBOX_ID>
```

### Laufzeitkonfiguration

```bash Bash icon="terminal" theme={"system"}
# Update idle timeout (60–86400 seconds)
novitaclaw config set <SANDBOX_ID> idle-timeout 600

# Update sandbox lifetime timeout (300–2592000 seconds)
novitaclaw config set <SANDBOX_ID> timeout 3600
```

Änderungen werden sofort wirksam. Der Agent innerhalb der Sandbox übernimmt die neue Konfiguration bei seinem nächsten Prüfzyklus.

### Funktionsweise

1. **Leerlauferkennung** — Ein Agent-Daemon innerhalb der Sandbox prüft regelmäßig die OpenClaw-Sitzungsaktivität und schreibt den Status nach `/tmp/.novitaclaw-status.json`.
2. **Automatisches Pausieren** — Der serverseitige Leerlaufmonitor liest den Agent-Status. Nach 2 aufeinanderfolgenden Leerlaufprüfungen wird die Sandbox automatisch pausiert.
3. **Automatisches Fortsetzen** — Eingehende Webhook-Anfragen oder Zugriffe über die Web UI setzen eine pausierte Sandbox automatisch fort.
4. **Cron-Vorwecken** — Der Scheduler durchsucht pausierte Sandboxes nach anstehenden Cron-Zeitplänen und setzt sie ca. 120 Sekunden vor dem nächsten Job-Start fort, damit Cron-Jobs pünktlich ausgeführt werden.

### Status prüfen

```bash Bash icon="terminal" theme={"system"}
# View sandbox status (does not trigger resume when paused)
novitaclaw status <SANDBOX_ID>

# List shows sandbox_type and state columns
novitaclaw list
```

Während die Sandbox pausiert ist, gibt der Befehl `status` weiterhin vollständige URL-Informationen zurück (aus der Datenbank gelesen, ohne eine Verbindung zur Sandbox herzustellen), sodass Skripte Adressen speichern können, ohne ein Fortsetzen auszulösen.

## Modelle konfigurieren

Ihre Instanz ist standardmäßig mit einem von Novita gehosteten Modell vorkonfiguriert. Um die von Ihrem Agent verwendeten Modelle zu ändern, navigieren Sie zu `Settings → Config`, klicken Sie auf **Raw**, um zur Raw-JSON5-Ansicht zu wechseln, und klicken Sie dann auf die Einblenden-Schaltfläche neben „secrets redacted“, um die vollständige Konfiguration anzuzeigen.

Aktualisieren Sie die folgenden zwei Abschnitte:

### Schritt 1: Modell unter Ihrem Provider registrieren

Fügen Sie dem Array `models` innerhalb von `models.providers.novita` ein neues Objekt hinzu:

```json theme={"system"}
{
  "models": {
    "providers": {
      "novita": {
        "models": [
          {
            "id": "model-id",
            "name": "display name",
            "reasoning": true,
            "input": ["text"],
            "contextWindow": 200000,
            "maxTokens": 50000
          }
        ]
      }
    }
  }
}
```

### Schritt 2: Als primäres Modell oder Fallback festlegen

Aktualisieren Sie das Feld `model` unter `agents.defaults`, sodass es Ihr Modell im Format `provider/model-id` referenziert:

```json theme={"system"}
{
  "agents": {
    "defaults": {
      "model": {
        "primary": "novita/model-id",
        "fallbacks": ["novita/fallback-model-id"]
      }
    }
  }
}
```

Klicken Sie auf **Update**, um zu speichern. Jedes auf der [Novita-Plattform](https://novita.ai/model-api/product/llm-api) verfügbare LLM wird unterstützt. Auch Drittanbieter-Provider können konfiguriert werden — wenn Sie Ihr eigenes LLM verwenden, zahlen Sie nur für die Sandbox-Laufzeit, nicht für die Nutzung von Novita-Modellen.

<Frame>
  <img src="https://mintcdn.com/novitaai/QcGDqn4gh3xIo9UN/de/guides/images/openclaw-cli/model-config.png?fit=max&auto=format&n=QcGDqn4gh3xIo9UN&q=85&s=02c8391b631761c53eab7b28a2010809" alt="NovitaClaw-Modellkonfiguration" width="1280" height="920" data-path="de/guides/images/openclaw-cli/model-config.png" />
</Frame>

## Kanäle verbinden

OpenClaw unterstützt externe Messaging-Kanäle, sodass Ihr Agent außerhalb der Web UI erreichbar ist. Kanäle sind standardmäßig deaktiviert und müssen konfiguriert werden.

### Telegram

Verbinden Sie Ihren Agent mit Telegram als Messaging-Kanal. Zwei Verbindungsmodi werden unterstützt: **Polling** (Standard, Long-Poll — keine öffentliche URL erforderlich) und **Webhook** (HTTP-Push — am besten für On-Demand-Sandboxes).

**Schritt 1: Telegram-Bot erstellen**

1. Öffnen Sie Telegram und suchen Sie [@BotFather](https://t.me/BotFather).
2. Senden Sie `/newbot` und folgen Sie den Anweisungen, um Ihren Bot zu benennen.
3. Kopieren Sie das Bot-Token, das BotFather bereitstellt.

#### Modus 1: Polling

Der Polling-Modus verwendet Long-Poll-Verbindungen. Es ist keine öffentliche URL erforderlich — am einfachsten zu konfigurieren.

<Warning>
  Der Polling-Modus wird für On-Demand-Sandboxes nicht empfohlen. Wenn die Sandbox automatisch pausiert, wird die Verbindung getrennt und eingehende Nachrichten gehen verloren. Verwenden Sie den Webhook-Modus für On-Demand-Sandboxes.
</Warning>

```bash Bash icon="terminal" theme={"system"}
novitaclaw pair telegram <SANDBOX_ID> \
  --bot-token <BOT_TOKEN>
```

#### Modus 2: Webhook

Der Webhook-Modus erfordert, dass die Sandbox einen HTTP-Port für den Empfang von Telegram-Push-Events bereitstellt. Am besten geeignet für On-Demand-Sandboxes — eingehende Webhook-Anfragen lösen automatisch ein Fortsetzen aus.

<Tip>
  Die `--webhook-url` ist die öffentliche URL, die Ihrer Sandbox zugewiesen ist. Führen Sie den folgenden Befehl aus, um sie abzurufen:

  ```bash Bash icon="terminal" theme={"system"}
  novitaclaw status <SANDBOX_ID> --json | jq -r '.telegram_webhook_url'
  ```
</Tip>

```bash Bash icon="terminal" theme={"system"}
novitaclaw pair telegram <SANDBOX_ID> \
  --bot-token <BOT_TOKEN> \
  --mode webhook \
  --webhook-url <WEBHOOK_URL> \
  --webhook-secret <SECRET>
```

#### Optionale Webhook-Parameter

| Parameter        | Standard            | Beschreibung                     |
| ---------------- | ------------------- | -------------------------------- |
| `--webhook-host` | `0.0.0.0`           | Bind-Adresse des Webhook-Servers |
| `--webhook-port` | `8787`              | Webhook-Listen-Port              |
| `--webhook-path` | `/webhook/telegram` | Webhook-URL-Pfad                 |
| `--dm-policy`    | `pairing`           | DM-Richtlinie                    |

#### Kopplungsablauf

Beim ersten Gespräch antwortet der Bot mit einem Kopplungscode:

```bash Bash icon="terminal" theme={"system"}
# List pending pairing requests
novitaclaw pair list <SANDBOX_ID> --channel telegram

# Approve a pairing request
novitaclaw pair approve <SANDBOX_ID> --channel telegram --code <CODE>
```

#### Modusvergleich

|                           | Polling                                                     | Webhook                                   |
| ------------------------- | ----------------------------------------------------------- | ----------------------------------------- |
| Verbindung                | Ausgehend (Long-Poll)                                       | Eingehend (HTTP-Push)                     |
| Öffentlicher Port         | Nicht erforderlich                                          | Erforderlich                              |
| Einrichtungsaufwand       | Niedrig                                                     | Mittel (zusätzliche Secrets)              |
| On-Demand-Auto-Fortsetzen | Nicht unterstützt (Verbindung wird beim Pausieren getrennt) | Unterstützt (Webhook löst Fortsetzen aus) |
| Empfohlen für             | Always-on-Sandboxes, Entwicklung                            | On-Demand-Sandboxes, Produktions-IM       |

### Slack

Verbinden Sie Ihren Agent mit Slack als Messaging-Kanal. Zwei Verbindungsmodi werden unterstützt: **Socket** (Standard, WebSocket — keine öffentliche URL erforderlich) und **HTTP** (Events-API-Webhook — am besten für On-Demand-Sandboxes).

#### Modus 1: Socket

Der Socket-Modus verwendet eine WebSocket-Verbindung. Es ist keine öffentliche URL erforderlich — am einfachsten zu konfigurieren.

<Warning>
  Der Socket-Modus wird für On-Demand-Sandboxes nicht empfohlen. Wenn die Sandbox automatisch pausiert, wird die WebSocket-Verbindung getrennt und eingehende Nachrichten gehen verloren. Verwenden Sie den HTTP-Modus für On-Demand-Sandboxes.
</Warning>

```bash Bash icon="terminal" theme={"system"}
novitaclaw pair slack <SANDBOX_ID> \
  --bot-token xoxb-... \
  --app-token xapp-...
```

#### Modus 2: HTTP

Der HTTP-Modus verwendet Slack-Events-API-Webhooks. Am besten geeignet für On-Demand-Sandboxes — eingehende Webhook-Anfragen lösen automatisch ein Fortsetzen aus.

```bash Bash icon="terminal" theme={"system"}
novitaclaw pair slack <SANDBOX_ID> \
  --bot-token xoxb-... \
  --mode http \
  --signing-secret <SECRET>
```

#### Optionale HTTP-Parameter

| Parameter        | Standard         | Beschreibung                     |
| ---------------- | ---------------- | -------------------------------- |
| `--webhook-host` | `0.0.0.0`        | Bind-Adresse des Webhook-Servers |
| `--webhook-port` | `8788`           | Webhook-Listen-Port              |
| `--webhook-path` | `/webhook/slack` | Webhook-URL-Pfad                 |

#### Kopplungsablauf

Beim ersten Gespräch antwortet der Bot mit einem Kopplungscode:

```bash Bash icon="terminal" theme={"system"}
# List pending pairing requests
novitaclaw pair list <SANDBOX_ID> --channel slack

# Approve a pairing request
novitaclaw pair approve <SANDBOX_ID> --channel slack --code <CODE>
```

#### Modusvergleich

|                           | Socket                                                      | HTTP                                      |
| ------------------------- | ----------------------------------------------------------- | ----------------------------------------- |
| Verbindung                | WebSocket (ausgehend)                                       | HTTP-Push (eingehend)                     |
| Öffentlicher Port         | Nicht erforderlich                                          | Erforderlich                              |
| Einrichtungsaufwand       | Niedrig                                                     | Mittel (zusätzliche Secrets)              |
| On-Demand-Auto-Fortsetzen | Nicht unterstützt (Verbindung wird beim Pausieren getrennt) | Unterstützt (Webhook löst Fortsetzen aus) |
| Empfohlen für             | Always-on-Sandboxes, Entwicklung                            | On-Demand-Sandboxes, Produktions-IM       |

### Kanalstatus

`novitaclaw status` zeigt Webhook-URLs für alle konfigurierten Kanäle an:

```bash Bash icon="terminal" theme={"system"}
novitaclaw status <SANDBOX_ID>
# Shows: Feishu Webhook, Telegram Webhook, Slack Webhook (when configured)

# JSON mode
novitaclaw status <SANDBOX_ID> --json | jq -r '.feishu_webhook_url'
novitaclaw status <SANDBOX_ID> --json | jq -r '.telegram_webhook_url'
novitaclaw status <SANDBOX_ID> --json | jq -r '.slack_webhook_url'
```

### Feishu

Verbinden Sie Ihren Agent mit Feishu (Lark) als Messaging-Kanal. Zwei Verbindungsmodi werden unterstützt: **Webhook** (HTTP-Push) und **Event** (WebSocket-Long-Poll).

#### Voraussetzungen: Feishu-App erstellen

1. Öffnen Sie die [Feishu Open Platform](https://open.feishu.cn/app), melden Sie sich an und klicken Sie auf **Create Custom App**.

2. Kopieren Sie auf der Seite **Credentials & Basic Info**:
   * **App ID** (Format: `cli_xxx`)
   * **App Secret**

3. Gehen Sie zu **Permission Management**, klicken Sie auf **Batch Import** und fügen Sie die folgenden Berechtigungen ein:

   ```json theme={"system"}
   {
     "scopes": {
       "tenant": [
         "im:message", "im:message:send_as_bot", "im:message:readonly",
         "im:message.p2p_msg:readonly", "im:message.group_at_msg:readonly",
         "im:resource", "im:chat.access_event.bot_p2p_chat:read",
         "im:chat.members:bot_access"
       ],
       "user": ["im:chat.access_event.bot_p2p_chat:read"]
     }
   }
   ```

4. Gehen Sie zu **App Capabilities > Bot** und aktivieren Sie die Bot-Funktion.

5. Erstellen Sie eine Version und veröffentlichen Sie die App.

#### Modus 1: Webhook

Der Webhook-Modus erfordert, dass die Sandbox einen HTTP-Port für den Empfang von Feishu-Push-Events bereitstellt. Am besten geeignet für On-Demand-Sandboxes — eingehende Webhook-Anfragen lösen automatisch ein Fortsetzen aus.

**Zusätzliche Anmeldedaten:** Gehen Sie auf der Feishu Open Platform zu **Development Configuration > Events & Callbacks > Encryption Strategy** und kopieren Sie:

* **Verification Token**
* **Encrypt Key**

```bash Bash icon="terminal" theme={"system"}
novitaclaw pair feishu <SANDBOX_ID> \
  --app-id cli_xxx \
  --app-secret secret_xxx \
  --mode webhook \
  --verification-token tok_xxx \
  --encrypt-key key_xxx
```

Auf der Seite **Event Subscription** der Feishu Open Platform:

1. Wählen Sie **Request URL Configuration**
2. Geben Sie die Webhook-URL ein — Sie erhalten sie über:
   ```bash Bash icon="terminal" theme={"system"}
   novitaclaw status <SANDBOX_ID> --json | jq -r '.feishu_webhook_url'
   ```
3. Fügen Sie das Event hinzu: `im.message.receive_v1`

#### Modus 2: Event

Der Event-Modus verwendet eine Feishu-WebSocket-Long-Poll-Verbindung. Es ist keine öffentliche URL erforderlich — am einfachsten zu konfigurieren.

<Warning>
  Der Event-Modus wird für On-Demand-Sandboxes nicht empfohlen. Wenn die Sandbox automatisch pausiert, wird die WebSocket-Verbindung getrennt und eingehende Nachrichten gehen verloren. Verwenden Sie den Webhook-Modus für On-Demand-Sandboxes.
</Warning>

```bash Bash icon="terminal" theme={"system"}
novitaclaw pair feishu <SANDBOX_ID> \
  --app-id cli_xxx \
  --app-secret secret_xxx
```

Nach der Konfiguration auf der Seite **Event Subscription** der Feishu Open Platform:

1. Wählen Sie **Use Long Connection to Receive Events**
2. Fügen Sie das Event hinzu: `im.message.receive_v1`

<Note>
  Stellen Sie sicher, dass das Gateway läuft (`novitaclaw status <SANDBOX_ID>`), bevor Sie speichern, andernfalls kann Feishu die Long-Connection-Konfiguration möglicherweise nicht speichern.
</Note>

#### Optionale Webhook-Parameter

| Parameter        | Standard         | Beschreibung                     |
| ---------------- | ---------------- | -------------------------------- |
| `--webhook-host` | `0.0.0.0`        | Bind-Adresse des Webhook-Servers |
| `--webhook-port` | `3000`           | Webhook-Listen-Port              |
| `--webhook-path` | `/feishu/events` | Webhook-URL-Pfad                 |

#### Kopplungsablauf

Feishu verwendet standardmäßig eine `pairing`-Strategie. Beim ersten Gespräch antwortet der Bot mit einem Kopplungscode, der über die CLI genehmigt werden muss:

```bash Bash icon="terminal" theme={"system"}
# List pending pairing requests
novitaclaw pair list <SANDBOX_ID> --channel feishu

# Approve a pairing request
novitaclaw pair approve <SANDBOX_ID> --channel feishu --code <CODE>
```

#### Modusvergleich

|                           | Event                            | Webhook                                   |
| ------------------------- | -------------------------------- | ----------------------------------------- |
| Verbindung                | WebSocket-Long-Poll (ausgehend)  | HTTP-Push (eingehend)                     |
| Öffentlicher Port         | Nicht erforderlich               | Erforderlich (Standard 3000)              |
| Einrichtungsaufwand       | Niedrig (nur App ID + Secret)    | Mittel (zusätzliches Token + Key)         |
| On-Demand-Auto-Fortsetzen | Nicht unterstützt                | Unterstützt (Webhook löst Fortsetzen aus) |
| Empfohlen für             | Always-on-Sandboxes, Entwicklung | On-Demand-Sandboxes, Produktions-IM       |

## Service-Zuverlässigkeit

Alle Kerndienste in der Sandbox werden von systemd verwaltet und bieten Zuverlässigkeit auf Produktionsniveau:

| Dienst                      | Beschreibung                        | Auto-Restart |
| --------------------------- | ----------------------------------- | ------------ |
| OpenClaw Gateway            | Agent-Laufzeit und WebSocket-Server | ✅            |
| Web Terminal (ttyd)         | Browserbasierter Terminalzugriff    | ✅            |
| File Manager (gohttpserver) | Webbasierte Dateiverwaltung         | ✅            |

**Automatische Crash-Wiederherstellung:** Wenn das Gateway wiederholt abstürzt, führt das System automatisch Diagnosen aus, versucht eine Reparatur und stellt die letzte bekannte funktionsfähige Konfiguration aus einem Backup wieder her — kein manueller Eingriff erforderlich.

**Automatisches Konfigurations-Backup:** Jeder Konfigurationsschreibvorgang erstellt automatisch ein Backup. Wenn eine fehlerhafte Konfiguration einen Absturz verursacht, stellt der Wiederherstellungsprozess die neueste gültige Sicherung wieder her.
